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_history_pb2 import * 52from .accounts_history_pb2_grpc import * 53from .activities_pb2 import * 54from .activities_pb2_grpc import * 55from .approval_workflow_approvers_pb2 import * 56from .approval_workflow_approvers_pb2_grpc import * 57from .approval_workflow_approvers_history_pb2 import * 58from .approval_workflow_approvers_history_pb2_grpc import * 59from .approval_workflow_steps_pb2 import * 60from .approval_workflow_steps_pb2_grpc import * 61from .approval_workflow_steps_history_pb2 import * 62from .approval_workflow_steps_history_pb2_grpc import * 63from .approval_workflows_pb2 import * 64from .approval_workflows_pb2_grpc import * 65from .approval_workflows_history_pb2 import * 66from .approval_workflows_history_pb2_grpc import * 67from .control_panel_pb2 import * 68from .control_panel_pb2_grpc import * 69from .health_checks_pb2 import * 70from .health_checks_pb2_grpc import * 71from .identity_aliases_pb2 import * 72from .identity_aliases_pb2_grpc import * 73from .identity_aliases_history_pb2 import * 74from .identity_aliases_history_pb2_grpc import * 75from .identity_sets_pb2 import * 76from .identity_sets_pb2_grpc import * 77from .identity_sets_history_pb2 import * 78from .identity_sets_history_pb2_grpc import * 79from .managed_secrets_pb2 import * 80from .managed_secrets_pb2_grpc import * 81from .nodes_pb2 import * 82from .nodes_pb2_grpc import * 83from .nodes_history_pb2 import * 84from .nodes_history_pb2_grpc import * 85from .organization_history_pb2 import * 86from .organization_history_pb2_grpc import * 87from .peering_group_nodes_pb2 import * 88from .peering_group_nodes_pb2_grpc import * 89from .peering_group_peers_pb2 import * 90from .peering_group_peers_pb2_grpc import * 91from .peering_group_resources_pb2 import * 92from .peering_group_resources_pb2_grpc import * 93from .peering_groups_pb2 import * 94from .peering_groups_pb2_grpc import * 95from .policies_pb2 import * 96from .policies_pb2_grpc import * 97from .policies_history_pb2 import * 98from .policies_history_pb2_grpc import * 99from .proxy_cluster_keys_pb2 import * 100from .proxy_cluster_keys_pb2_grpc import * 101from .queries_pb2 import * 102from .queries_pb2_grpc import * 103from .remote_identities_pb2 import * 104from .remote_identities_pb2_grpc import * 105from .remote_identities_history_pb2 import * 106from .remote_identities_history_pb2_grpc import * 107from .remote_identity_groups_pb2 import * 108from .remote_identity_groups_pb2_grpc import * 109from .remote_identity_groups_history_pb2 import * 110from .remote_identity_groups_history_pb2_grpc import * 111from .replays_pb2 import * 112from .replays_pb2_grpc import * 113from .resources_pb2 import * 114from .resources_pb2_grpc import * 115from .resources_history_pb2 import * 116from .resources_history_pb2_grpc import * 117from .role_resources_pb2 import * 118from .role_resources_pb2_grpc import * 119from .role_resources_history_pb2 import * 120from .role_resources_history_pb2_grpc import * 121from .roles_pb2 import * 122from .roles_pb2_grpc import * 123from .roles_history_pb2 import * 124from .roles_history_pb2_grpc import * 125from .secret_engine_policy_pb2 import * 126from .secret_engine_policy_pb2_grpc import * 127from .secret_engine_types_pb2 import * 128from .secret_engine_types_pb2_grpc import * 129from .secret_store_types_pb2 import * 130from .secret_store_types_pb2_grpc import * 131from .secret_stores_pb2 import * 132from .secret_stores_pb2_grpc import * 133from .secret_engines_pb2 import * 134from .secret_engines_pb2_grpc import * 135from .secret_store_healths_pb2 import * 136from .secret_store_healths_pb2_grpc import * 137from .secret_stores_history_pb2 import * 138from .secret_stores_history_pb2_grpc import * 139from .workflow_approvers_pb2 import * 140from .workflow_approvers_pb2_grpc import * 141from .workflow_approvers_history_pb2 import * 142from .workflow_approvers_history_pb2_grpc import * 143from .workflow_assignments_pb2 import * 144from .workflow_assignments_pb2_grpc import * 145from .workflow_assignments_history_pb2 import * 146from .workflow_assignments_history_pb2_grpc import * 147from .workflow_roles_pb2 import * 148from .workflow_roles_pb2_grpc import * 149from .workflow_roles_history_pb2 import * 150from .workflow_roles_history_pb2_grpc import * 151from .workflows_pb2 import * 152from .workflows_pb2_grpc import * 153from .workflows_history_pb2 import * 154from .workflows_history_pb2_grpc import * 155import warnings 156import functools 157import time 158 159 160def deprecated(func): 161 """This is a decorator which can be used to mark functions 162 as deprecated. It will result in a warning being emitted 163 when the function is used.""" 164 @functools.wraps(func) 165 def new_func(*args, **kwargs): 166 warnings.warn("Call to deprecated function {}.".format(func.__name__), 167 category=DeprecationWarning, 168 stacklevel=2) 169 return func(*args, **kwargs) 170 171 return new_func 172 173 174class AccessRequests: 175 ''' 176 AccessRequests are requests for access to a resource that may match a Workflow. 177 See `strongdm.models.AccessRequest`. 178 ''' 179 def __init__(self, channel, client): 180 self.parent = client 181 self.stub = AccessRequestsStub(channel) 182 183 def list(self, filter, *args, timeout=None): 184 ''' 185 Lists existing access requests. 186 ''' 187 deadline = None if timeout is None else time.time() + timeout 188 req = AccessRequestListRequest() 189 req.meta.CopyFrom(ListRequestMetadata()) 190 if self.parent.page_limit > 0: 191 req.meta.limit = self.parent.page_limit 192 if self.parent.snapshot_datetime is not None: 193 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 194 195 req.filter = plumbing.quote_filter_args(filter, *args) 196 197 def generator(svc, req): 198 tries = 0 199 while True: 200 t = None if deadline is None else deadline - time.time() 201 try: 202 plumbing_response = svc.stub.List( 203 req, 204 metadata=svc.parent.get_metadata( 205 'AccessRequests.List', req), 206 timeout=t) 207 except Exception as e: 208 if self.parent.shouldRetry(tries, e, deadline): 209 tries += 1 210 time.sleep( 211 self.parent.exponentialBackoff(tries, deadline)) 212 continue 213 raise plumbing.convert_error_to_porcelain(e) from e 214 tries = 0 215 for plumbing_item in plumbing_response.access_requests: 216 yield plumbing.convert_access_request_to_porcelain( 217 plumbing_item) 218 if plumbing_response.meta.next_cursor == '': 219 break 220 req.meta.cursor = plumbing_response.meta.next_cursor 221 222 return generator(self, req) 223 224 225class SnapshotAccessRequests: 226 ''' 227 SnapshotAccessRequests exposes the read only methods of the AccessRequests 228 service for historical queries. 229 ''' 230 def __init__(self, access_requests): 231 self.access_requests = access_requests 232 233 def list(self, filter, *args, timeout=None): 234 ''' 235 Lists existing access requests. 236 ''' 237 return self.access_requests.list(filter, *args, timeout=timeout) 238 239 240class AccessRequestEventsHistory: 241 ''' 242 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 243 See `strongdm.models.AccessRequestEventHistory`. 244 ''' 245 def __init__(self, channel, client): 246 self.parent = client 247 self.stub = AccessRequestEventsHistoryStub(channel) 248 249 def list(self, filter, *args, timeout=None): 250 ''' 251 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 252 ''' 253 deadline = None if timeout is None else time.time() + timeout 254 req = AccessRequestEventHistoryListRequest() 255 req.meta.CopyFrom(ListRequestMetadata()) 256 if self.parent.page_limit > 0: 257 req.meta.limit = self.parent.page_limit 258 if self.parent.snapshot_datetime is not None: 259 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 260 261 req.filter = plumbing.quote_filter_args(filter, *args) 262 263 def generator(svc, req): 264 tries = 0 265 while True: 266 t = None if deadline is None else deadline - time.time() 267 try: 268 plumbing_response = svc.stub.List( 269 req, 270 metadata=svc.parent.get_metadata( 271 'AccessRequestEventsHistory.List', req), 272 timeout=t) 273 except Exception as e: 274 if self.parent.shouldRetry(tries, e, deadline): 275 tries += 1 276 time.sleep( 277 self.parent.exponentialBackoff(tries, deadline)) 278 continue 279 raise plumbing.convert_error_to_porcelain(e) from e 280 tries = 0 281 for plumbing_item in plumbing_response.history: 282 yield plumbing.convert_access_request_event_history_to_porcelain( 283 plumbing_item) 284 if plumbing_response.meta.next_cursor == '': 285 break 286 req.meta.cursor = plumbing_response.meta.next_cursor 287 288 return generator(self, req) 289 290 291class AccessRequestsHistory: 292 ''' 293 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 294 See `strongdm.models.AccessRequestHistory`. 295 ''' 296 def __init__(self, channel, client): 297 self.parent = client 298 self.stub = AccessRequestsHistoryStub(channel) 299 300 def list(self, filter, *args, timeout=None): 301 ''' 302 List gets a list of AccessRequestHistory records matching a given set of criteria. 303 ''' 304 deadline = None if timeout is None else time.time() + timeout 305 req = AccessRequestHistoryListRequest() 306 req.meta.CopyFrom(ListRequestMetadata()) 307 if self.parent.page_limit > 0: 308 req.meta.limit = self.parent.page_limit 309 if self.parent.snapshot_datetime is not None: 310 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 311 312 req.filter = plumbing.quote_filter_args(filter, *args) 313 314 def generator(svc, req): 315 tries = 0 316 while True: 317 t = None if deadline is None else deadline - time.time() 318 try: 319 plumbing_response = svc.stub.List( 320 req, 321 metadata=svc.parent.get_metadata( 322 'AccessRequestsHistory.List', req), 323 timeout=t) 324 except Exception as e: 325 if self.parent.shouldRetry(tries, e, deadline): 326 tries += 1 327 time.sleep( 328 self.parent.exponentialBackoff(tries, deadline)) 329 continue 330 raise plumbing.convert_error_to_porcelain(e) from e 331 tries = 0 332 for plumbing_item in plumbing_response.history: 333 yield plumbing.convert_access_request_history_to_porcelain( 334 plumbing_item) 335 if plumbing_response.meta.next_cursor == '': 336 break 337 req.meta.cursor = plumbing_response.meta.next_cursor 338 339 return generator(self, req) 340 341 342class AccountAttachments: 343 ''' 344 AccountAttachments assign an account to a role. 345 See `strongdm.models.AccountAttachment`. 346 ''' 347 def __init__(self, channel, client): 348 self.parent = client 349 self.stub = AccountAttachmentsStub(channel) 350 351 def create(self, account_attachment, timeout=None): 352 ''' 353 Create registers a new AccountAttachment. 354 ''' 355 deadline = None if timeout is None else time.time() + timeout 356 req = AccountAttachmentCreateRequest() 357 358 if account_attachment is not None: 359 req.account_attachment.CopyFrom( 360 plumbing.convert_account_attachment_to_plumbing( 361 account_attachment)) 362 tries = 0 363 plumbing_response = None 364 while True: 365 t = None if deadline is None else deadline - time.time() 366 try: 367 plumbing_response = self.stub.Create( 368 req, 369 metadata=self.parent.get_metadata( 370 'AccountAttachments.Create', req), 371 timeout=t) 372 except Exception as e: 373 if self.parent.shouldRetry(tries, e, deadline): 374 tries += 1 375 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 376 continue 377 raise plumbing.convert_error_to_porcelain(e) from e 378 break 379 380 resp = models.AccountAttachmentCreateResponse() 381 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 382 plumbing_response.account_attachment) 383 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 384 plumbing_response.meta) 385 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 386 plumbing_response.rate_limit) 387 return resp 388 389 def get(self, id, timeout=None): 390 ''' 391 Get reads one AccountAttachment by ID. 392 ''' 393 deadline = None if timeout is None else time.time() + timeout 394 req = AccountAttachmentGetRequest() 395 if self.parent.snapshot_datetime is not None: 396 req.meta.CopyFrom(GetRequestMetadata()) 397 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 398 399 req.id = (id) 400 tries = 0 401 plumbing_response = None 402 while True: 403 t = None if deadline is None else deadline - time.time() 404 try: 405 plumbing_response = self.stub.Get( 406 req, 407 metadata=self.parent.get_metadata('AccountAttachments.Get', 408 req), 409 timeout=t) 410 except Exception as e: 411 if self.parent.shouldRetry(tries, e, deadline): 412 tries += 1 413 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 414 continue 415 raise plumbing.convert_error_to_porcelain(e) from e 416 break 417 418 resp = models.AccountAttachmentGetResponse() 419 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 420 plumbing_response.account_attachment) 421 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 422 plumbing_response.meta) 423 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 424 plumbing_response.rate_limit) 425 return resp 426 427 def delete(self, id, timeout=None): 428 ''' 429 Delete removes a AccountAttachment by ID. 430 ''' 431 deadline = None if timeout is None else time.time() + timeout 432 req = AccountAttachmentDeleteRequest() 433 434 req.id = (id) 435 tries = 0 436 plumbing_response = None 437 while True: 438 t = None if deadline is None else deadline - time.time() 439 try: 440 plumbing_response = self.stub.Delete( 441 req, 442 metadata=self.parent.get_metadata( 443 'AccountAttachments.Delete', req), 444 timeout=t) 445 except Exception as e: 446 if self.parent.shouldRetry(tries, e, deadline): 447 tries += 1 448 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 449 continue 450 raise plumbing.convert_error_to_porcelain(e) from e 451 break 452 453 resp = models.AccountAttachmentDeleteResponse() 454 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 455 plumbing_response.meta) 456 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 457 plumbing_response.rate_limit) 458 return resp 459 460 def list(self, filter, *args, timeout=None): 461 ''' 462 List gets a list of AccountAttachments matching a given set of criteria. 463 ''' 464 deadline = None if timeout is None else time.time() + timeout 465 req = AccountAttachmentListRequest() 466 req.meta.CopyFrom(ListRequestMetadata()) 467 if self.parent.page_limit > 0: 468 req.meta.limit = self.parent.page_limit 469 if self.parent.snapshot_datetime is not None: 470 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 471 472 req.filter = plumbing.quote_filter_args(filter, *args) 473 474 def generator(svc, req): 475 tries = 0 476 while True: 477 t = None if deadline is None else deadline - time.time() 478 try: 479 plumbing_response = svc.stub.List( 480 req, 481 metadata=svc.parent.get_metadata( 482 'AccountAttachments.List', req), 483 timeout=t) 484 except Exception as e: 485 if self.parent.shouldRetry(tries, e, deadline): 486 tries += 1 487 time.sleep( 488 self.parent.exponentialBackoff(tries, deadline)) 489 continue 490 raise plumbing.convert_error_to_porcelain(e) from e 491 tries = 0 492 for plumbing_item in plumbing_response.account_attachments: 493 yield plumbing.convert_account_attachment_to_porcelain( 494 plumbing_item) 495 if plumbing_response.meta.next_cursor == '': 496 break 497 req.meta.cursor = plumbing_response.meta.next_cursor 498 499 return generator(self, req) 500 501 502class SnapshotAccountAttachments: 503 ''' 504 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 505 service for historical queries. 506 ''' 507 def __init__(self, account_attachments): 508 self.account_attachments = account_attachments 509 510 def get(self, id, timeout=None): 511 ''' 512 Get reads one AccountAttachment by ID. 513 ''' 514 return self.account_attachments.get(id, timeout=timeout) 515 516 def list(self, filter, *args, timeout=None): 517 ''' 518 List gets a list of AccountAttachments matching a given set of criteria. 519 ''' 520 return self.account_attachments.list(filter, *args, timeout=timeout) 521 522 523class AccountAttachmentsHistory: 524 ''' 525 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 526 See `strongdm.models.AccountAttachmentHistory`. 527 ''' 528 def __init__(self, channel, client): 529 self.parent = client 530 self.stub = AccountAttachmentsHistoryStub(channel) 531 532 def list(self, filter, *args, timeout=None): 533 ''' 534 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 535 ''' 536 deadline = None if timeout is None else time.time() + timeout 537 req = AccountAttachmentHistoryListRequest() 538 req.meta.CopyFrom(ListRequestMetadata()) 539 if self.parent.page_limit > 0: 540 req.meta.limit = self.parent.page_limit 541 if self.parent.snapshot_datetime is not None: 542 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 543 544 req.filter = plumbing.quote_filter_args(filter, *args) 545 546 def generator(svc, req): 547 tries = 0 548 while True: 549 t = None if deadline is None else deadline - time.time() 550 try: 551 plumbing_response = svc.stub.List( 552 req, 553 metadata=svc.parent.get_metadata( 554 'AccountAttachmentsHistory.List', req), 555 timeout=t) 556 except Exception as e: 557 if self.parent.shouldRetry(tries, e, deadline): 558 tries += 1 559 time.sleep( 560 self.parent.exponentialBackoff(tries, deadline)) 561 continue 562 raise plumbing.convert_error_to_porcelain(e) from e 563 tries = 0 564 for plumbing_item in plumbing_response.history: 565 yield plumbing.convert_account_attachment_history_to_porcelain( 566 plumbing_item) 567 if plumbing_response.meta.next_cursor == '': 568 break 569 req.meta.cursor = plumbing_response.meta.next_cursor 570 571 return generator(self, req) 572 573 574class AccountGrants: 575 ''' 576 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 577 See `strongdm.models.AccountGrant`. 578 ''' 579 def __init__(self, channel, client): 580 self.parent = client 581 self.stub = AccountGrantsStub(channel) 582 583 def create(self, account_grant, timeout=None): 584 ''' 585 Create registers a new AccountGrant. 586 ''' 587 deadline = None if timeout is None else time.time() + timeout 588 req = AccountGrantCreateRequest() 589 590 if account_grant is not None: 591 req.account_grant.CopyFrom( 592 plumbing.convert_account_grant_to_plumbing(account_grant)) 593 tries = 0 594 plumbing_response = None 595 while True: 596 t = None if deadline is None else deadline - time.time() 597 try: 598 plumbing_response = self.stub.Create( 599 req, 600 metadata=self.parent.get_metadata('AccountGrants.Create', 601 req), 602 timeout=t) 603 except Exception as e: 604 if self.parent.shouldRetry(tries, e, deadline): 605 tries += 1 606 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 607 continue 608 raise plumbing.convert_error_to_porcelain(e) from e 609 break 610 611 resp = models.AccountGrantCreateResponse() 612 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 613 plumbing_response.account_grant) 614 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 615 plumbing_response.meta) 616 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 617 plumbing_response.rate_limit) 618 return resp 619 620 def get(self, id, timeout=None): 621 ''' 622 Get reads one AccountGrant by ID. 623 ''' 624 deadline = None if timeout is None else time.time() + timeout 625 req = AccountGrantGetRequest() 626 if self.parent.snapshot_datetime is not None: 627 req.meta.CopyFrom(GetRequestMetadata()) 628 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 629 630 req.id = (id) 631 tries = 0 632 plumbing_response = None 633 while True: 634 t = None if deadline is None else deadline - time.time() 635 try: 636 plumbing_response = self.stub.Get( 637 req, 638 metadata=self.parent.get_metadata('AccountGrants.Get', 639 req), 640 timeout=t) 641 except Exception as e: 642 if self.parent.shouldRetry(tries, e, deadline): 643 tries += 1 644 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 645 continue 646 raise plumbing.convert_error_to_porcelain(e) from e 647 break 648 649 resp = models.AccountGrantGetResponse() 650 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 651 plumbing_response.account_grant) 652 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 653 plumbing_response.meta) 654 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 655 plumbing_response.rate_limit) 656 return resp 657 658 def delete(self, id, timeout=None): 659 ''' 660 Delete removes a AccountGrant by ID. 661 ''' 662 deadline = None if timeout is None else time.time() + timeout 663 req = AccountGrantDeleteRequest() 664 665 req.id = (id) 666 tries = 0 667 plumbing_response = None 668 while True: 669 t = None if deadline is None else deadline - time.time() 670 try: 671 plumbing_response = self.stub.Delete( 672 req, 673 metadata=self.parent.get_metadata('AccountGrants.Delete', 674 req), 675 timeout=t) 676 except Exception as e: 677 if self.parent.shouldRetry(tries, e, deadline): 678 tries += 1 679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 680 continue 681 raise plumbing.convert_error_to_porcelain(e) from e 682 break 683 684 resp = models.AccountGrantDeleteResponse() 685 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 686 plumbing_response.meta) 687 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 688 plumbing_response.rate_limit) 689 return resp 690 691 def list(self, filter, *args, timeout=None): 692 ''' 693 List gets a list of AccountGrants matching a given set of criteria. 694 ''' 695 deadline = None if timeout is None else time.time() + timeout 696 req = AccountGrantListRequest() 697 req.meta.CopyFrom(ListRequestMetadata()) 698 if self.parent.page_limit > 0: 699 req.meta.limit = self.parent.page_limit 700 if self.parent.snapshot_datetime is not None: 701 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 702 703 req.filter = plumbing.quote_filter_args(filter, *args) 704 705 def generator(svc, req): 706 tries = 0 707 while True: 708 t = None if deadline is None else deadline - time.time() 709 try: 710 plumbing_response = svc.stub.List( 711 req, 712 metadata=svc.parent.get_metadata( 713 'AccountGrants.List', req), 714 timeout=t) 715 except Exception as e: 716 if self.parent.shouldRetry(tries, e, deadline): 717 tries += 1 718 time.sleep( 719 self.parent.exponentialBackoff(tries, deadline)) 720 continue 721 raise plumbing.convert_error_to_porcelain(e) from e 722 tries = 0 723 for plumbing_item in plumbing_response.account_grants: 724 yield plumbing.convert_account_grant_to_porcelain( 725 plumbing_item) 726 if plumbing_response.meta.next_cursor == '': 727 break 728 req.meta.cursor = plumbing_response.meta.next_cursor 729 730 return generator(self, req) 731 732 733class SnapshotAccountGrants: 734 ''' 735 SnapshotAccountGrants exposes the read only methods of the AccountGrants 736 service for historical queries. 737 ''' 738 def __init__(self, account_grants): 739 self.account_grants = account_grants 740 741 def get(self, id, timeout=None): 742 ''' 743 Get reads one AccountGrant by ID. 744 ''' 745 return self.account_grants.get(id, timeout=timeout) 746 747 def list(self, filter, *args, timeout=None): 748 ''' 749 List gets a list of AccountGrants matching a given set of criteria. 750 ''' 751 return self.account_grants.list(filter, *args, timeout=timeout) 752 753 754class AccountGrantsHistory: 755 ''' 756 AccountGrantsHistory records all changes to the state of an AccountGrant. 757 See `strongdm.models.AccountGrantHistory`. 758 ''' 759 def __init__(self, channel, client): 760 self.parent = client 761 self.stub = AccountGrantsHistoryStub(channel) 762 763 def list(self, filter, *args, timeout=None): 764 ''' 765 List gets a list of AccountGrantHistory records matching a given set of criteria. 766 ''' 767 deadline = None if timeout is None else time.time() + timeout 768 req = AccountGrantHistoryListRequest() 769 req.meta.CopyFrom(ListRequestMetadata()) 770 if self.parent.page_limit > 0: 771 req.meta.limit = self.parent.page_limit 772 if self.parent.snapshot_datetime is not None: 773 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 774 775 req.filter = plumbing.quote_filter_args(filter, *args) 776 777 def generator(svc, req): 778 tries = 0 779 while True: 780 t = None if deadline is None else deadline - time.time() 781 try: 782 plumbing_response = svc.stub.List( 783 req, 784 metadata=svc.parent.get_metadata( 785 'AccountGrantsHistory.List', req), 786 timeout=t) 787 except Exception as e: 788 if self.parent.shouldRetry(tries, e, deadline): 789 tries += 1 790 time.sleep( 791 self.parent.exponentialBackoff(tries, deadline)) 792 continue 793 raise plumbing.convert_error_to_porcelain(e) from e 794 tries = 0 795 for plumbing_item in plumbing_response.history: 796 yield plumbing.convert_account_grant_history_to_porcelain( 797 plumbing_item) 798 if plumbing_response.meta.next_cursor == '': 799 break 800 req.meta.cursor = plumbing_response.meta.next_cursor 801 802 return generator(self, req) 803 804 805class AccountPermissions: 806 ''' 807 AccountPermissions records the granular permissions accounts have, allowing them to execute 808 relevant commands via StrongDM's APIs. 809 See `strongdm.models.AccountPermission`. 810 ''' 811 def __init__(self, channel, client): 812 self.parent = client 813 self.stub = AccountPermissionsStub(channel) 814 815 def list(self, filter, *args, timeout=None): 816 ''' 817 List gets a list of Permission records matching a given set of criteria. 818 ''' 819 deadline = None if timeout is None else time.time() + timeout 820 req = AccountPermissionListRequest() 821 req.meta.CopyFrom(ListRequestMetadata()) 822 if self.parent.page_limit > 0: 823 req.meta.limit = self.parent.page_limit 824 if self.parent.snapshot_datetime is not None: 825 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 826 827 req.filter = plumbing.quote_filter_args(filter, *args) 828 829 def generator(svc, req): 830 tries = 0 831 while True: 832 t = None if deadline is None else deadline - time.time() 833 try: 834 plumbing_response = svc.stub.List( 835 req, 836 metadata=svc.parent.get_metadata( 837 'AccountPermissions.List', req), 838 timeout=t) 839 except Exception as e: 840 if self.parent.shouldRetry(tries, e, deadline): 841 tries += 1 842 time.sleep( 843 self.parent.exponentialBackoff(tries, deadline)) 844 continue 845 raise plumbing.convert_error_to_porcelain(e) from e 846 tries = 0 847 for plumbing_item in plumbing_response.permissions: 848 yield plumbing.convert_account_permission_to_porcelain( 849 plumbing_item) 850 if plumbing_response.meta.next_cursor == '': 851 break 852 req.meta.cursor = plumbing_response.meta.next_cursor 853 854 return generator(self, req) 855 856 857class SnapshotAccountPermissions: 858 ''' 859 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 860 service for historical queries. 861 ''' 862 def __init__(self, account_permissions): 863 self.account_permissions = account_permissions 864 865 def list(self, filter, *args, timeout=None): 866 ''' 867 List gets a list of Permission records matching a given set of criteria. 868 ''' 869 return self.account_permissions.list(filter, *args, timeout=timeout) 870 871 872class AccountResources: 873 ''' 874 AccountResources enumerates the resources to which accounts have access. 875 The AccountResources service is read-only. 876 See `strongdm.models.AccountResource`. 877 ''' 878 def __init__(self, channel, client): 879 self.parent = client 880 self.stub = AccountResourcesStub(channel) 881 882 def list(self, filter, *args, timeout=None): 883 ''' 884 List gets a list of AccountResource records matching a given set of criteria. 885 ''' 886 deadline = None if timeout is None else time.time() + timeout 887 req = AccountResourceListRequest() 888 req.meta.CopyFrom(ListRequestMetadata()) 889 if self.parent.page_limit > 0: 890 req.meta.limit = self.parent.page_limit 891 if self.parent.snapshot_datetime is not None: 892 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 893 894 req.filter = plumbing.quote_filter_args(filter, *args) 895 896 def generator(svc, req): 897 tries = 0 898 while True: 899 t = None if deadline is None else deadline - time.time() 900 try: 901 plumbing_response = svc.stub.List( 902 req, 903 metadata=svc.parent.get_metadata( 904 'AccountResources.List', req), 905 timeout=t) 906 except Exception as e: 907 if self.parent.shouldRetry(tries, e, deadline): 908 tries += 1 909 time.sleep( 910 self.parent.exponentialBackoff(tries, deadline)) 911 continue 912 raise plumbing.convert_error_to_porcelain(e) from e 913 tries = 0 914 for plumbing_item in plumbing_response.account_resources: 915 yield plumbing.convert_account_resource_to_porcelain( 916 plumbing_item) 917 if plumbing_response.meta.next_cursor == '': 918 break 919 req.meta.cursor = plumbing_response.meta.next_cursor 920 921 return generator(self, req) 922 923 924class SnapshotAccountResources: 925 ''' 926 SnapshotAccountResources exposes the read only methods of the AccountResources 927 service for historical queries. 928 ''' 929 def __init__(self, account_resources): 930 self.account_resources = account_resources 931 932 def list(self, filter, *args, timeout=None): 933 ''' 934 List gets a list of AccountResource records matching a given set of criteria. 935 ''' 936 return self.account_resources.list(filter, *args, timeout=timeout) 937 938 939class AccountResourcesHistory: 940 ''' 941 AccountResourcesHistory records all changes to the state of a AccountResource. 942 See `strongdm.models.AccountResourceHistory`. 943 ''' 944 def __init__(self, channel, client): 945 self.parent = client 946 self.stub = AccountResourcesHistoryStub(channel) 947 948 def list(self, filter, *args, timeout=None): 949 ''' 950 List gets a list of AccountResourceHistory records matching a given set of criteria. 951 ''' 952 deadline = None if timeout is None else time.time() + timeout 953 req = AccountResourceHistoryListRequest() 954 req.meta.CopyFrom(ListRequestMetadata()) 955 if self.parent.page_limit > 0: 956 req.meta.limit = self.parent.page_limit 957 if self.parent.snapshot_datetime is not None: 958 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 959 960 req.filter = plumbing.quote_filter_args(filter, *args) 961 962 def generator(svc, req): 963 tries = 0 964 while True: 965 t = None if deadline is None else deadline - time.time() 966 try: 967 plumbing_response = svc.stub.List( 968 req, 969 metadata=svc.parent.get_metadata( 970 'AccountResourcesHistory.List', req), 971 timeout=t) 972 except Exception as e: 973 if self.parent.shouldRetry(tries, e, deadline): 974 tries += 1 975 time.sleep( 976 self.parent.exponentialBackoff(tries, deadline)) 977 continue 978 raise plumbing.convert_error_to_porcelain(e) from e 979 tries = 0 980 for plumbing_item in plumbing_response.history: 981 yield plumbing.convert_account_resource_history_to_porcelain( 982 plumbing_item) 983 if plumbing_response.meta.next_cursor == '': 984 break 985 req.meta.cursor = plumbing_response.meta.next_cursor 986 987 return generator(self, req) 988 989 990class Accounts: 991 ''' 992 Accounts are users that have access to strongDM. There are two types of accounts: 993 1. **Users:** humans who are authenticated through username and password or SSO. 994 2. **Service Accounts:** machines that are authenticated using a service token. 995 3. **Tokens** are access keys with permissions that can be used for authentication. 996 See: 997 `strongdm.models.Service` 998 `strongdm.models.Token` 999 `strongdm.models.User` 1000 ''' 1001 def __init__(self, channel, client): 1002 self.parent = client 1003 self.stub = AccountsStub(channel) 1004 1005 def create(self, account, timeout=None): 1006 ''' 1007 Create registers a new Account. 1008 ''' 1009 deadline = None if timeout is None else time.time() + timeout 1010 req = AccountCreateRequest() 1011 1012 if account is not None: 1013 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1014 tries = 0 1015 plumbing_response = None 1016 while True: 1017 t = None if deadline is None else deadline - time.time() 1018 try: 1019 plumbing_response = self.stub.Create( 1020 req, 1021 metadata=self.parent.get_metadata('Accounts.Create', req), 1022 timeout=t) 1023 except Exception as e: 1024 if self.parent.shouldRetry(tries, e, deadline): 1025 tries += 1 1026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1027 continue 1028 raise plumbing.convert_error_to_porcelain(e) from e 1029 break 1030 1031 resp = models.AccountCreateResponse() 1032 resp.access_key = (plumbing_response.access_key) 1033 resp.account = plumbing.convert_account_to_porcelain( 1034 plumbing_response.account) 1035 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1036 plumbing_response.meta) 1037 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1038 plumbing_response.rate_limit) 1039 resp.secret_key = (plumbing_response.secret_key) 1040 resp.token = (plumbing_response.token) 1041 return resp 1042 1043 def get(self, id, timeout=None): 1044 ''' 1045 Get reads one Account by ID. 1046 ''' 1047 deadline = None if timeout is None else time.time() + timeout 1048 req = AccountGetRequest() 1049 if self.parent.snapshot_datetime is not None: 1050 req.meta.CopyFrom(GetRequestMetadata()) 1051 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1052 1053 req.id = (id) 1054 tries = 0 1055 plumbing_response = None 1056 while True: 1057 t = None if deadline is None else deadline - time.time() 1058 try: 1059 plumbing_response = self.stub.Get( 1060 req, 1061 metadata=self.parent.get_metadata('Accounts.Get', req), 1062 timeout=t) 1063 except Exception as e: 1064 if self.parent.shouldRetry(tries, e, deadline): 1065 tries += 1 1066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1067 continue 1068 raise plumbing.convert_error_to_porcelain(e) from e 1069 break 1070 1071 resp = models.AccountGetResponse() 1072 resp.account = plumbing.convert_account_to_porcelain( 1073 plumbing_response.account) 1074 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1075 plumbing_response.meta) 1076 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1077 plumbing_response.rate_limit) 1078 return resp 1079 1080 def update(self, account, timeout=None): 1081 ''' 1082 Update replaces all the fields of an Account by ID. 1083 ''' 1084 deadline = None if timeout is None else time.time() + timeout 1085 req = AccountUpdateRequest() 1086 1087 if account is not None: 1088 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1089 tries = 0 1090 plumbing_response = None 1091 while True: 1092 t = None if deadline is None else deadline - time.time() 1093 try: 1094 plumbing_response = self.stub.Update( 1095 req, 1096 metadata=self.parent.get_metadata('Accounts.Update', req), 1097 timeout=t) 1098 except Exception as e: 1099 if self.parent.shouldRetry(tries, e, deadline): 1100 tries += 1 1101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1102 continue 1103 raise plumbing.convert_error_to_porcelain(e) from e 1104 break 1105 1106 resp = models.AccountUpdateResponse() 1107 resp.account = plumbing.convert_account_to_porcelain( 1108 plumbing_response.account) 1109 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1110 plumbing_response.meta) 1111 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1112 plumbing_response.rate_limit) 1113 return resp 1114 1115 def delete(self, id, timeout=None): 1116 ''' 1117 Delete removes an Account by ID. 1118 ''' 1119 deadline = None if timeout is None else time.time() + timeout 1120 req = AccountDeleteRequest() 1121 1122 req.id = (id) 1123 tries = 0 1124 plumbing_response = None 1125 while True: 1126 t = None if deadline is None else deadline - time.time() 1127 try: 1128 plumbing_response = self.stub.Delete( 1129 req, 1130 metadata=self.parent.get_metadata('Accounts.Delete', req), 1131 timeout=t) 1132 except Exception as e: 1133 if self.parent.shouldRetry(tries, e, deadline): 1134 tries += 1 1135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1136 continue 1137 raise plumbing.convert_error_to_porcelain(e) from e 1138 break 1139 1140 resp = models.AccountDeleteResponse() 1141 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1142 plumbing_response.meta) 1143 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1144 plumbing_response.rate_limit) 1145 return resp 1146 1147 def list(self, filter, *args, timeout=None): 1148 ''' 1149 List gets a list of Accounts matching a given set of criteria. 1150 ''' 1151 deadline = None if timeout is None else time.time() + timeout 1152 req = AccountListRequest() 1153 req.meta.CopyFrom(ListRequestMetadata()) 1154 if self.parent.page_limit > 0: 1155 req.meta.limit = self.parent.page_limit 1156 if self.parent.snapshot_datetime is not None: 1157 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1158 1159 req.filter = plumbing.quote_filter_args(filter, *args) 1160 1161 def generator(svc, req): 1162 tries = 0 1163 while True: 1164 t = None if deadline is None else deadline - time.time() 1165 try: 1166 plumbing_response = svc.stub.List( 1167 req, 1168 metadata=svc.parent.get_metadata('Accounts.List', req), 1169 timeout=t) 1170 except Exception as e: 1171 if self.parent.shouldRetry(tries, e, deadline): 1172 tries += 1 1173 time.sleep( 1174 self.parent.exponentialBackoff(tries, deadline)) 1175 continue 1176 raise plumbing.convert_error_to_porcelain(e) from e 1177 tries = 0 1178 for plumbing_item in plumbing_response.accounts: 1179 yield plumbing.convert_account_to_porcelain(plumbing_item) 1180 if plumbing_response.meta.next_cursor == '': 1181 break 1182 req.meta.cursor = plumbing_response.meta.next_cursor 1183 1184 return generator(self, req) 1185 1186 1187class SnapshotAccounts: 1188 ''' 1189 SnapshotAccounts exposes the read only methods of the Accounts 1190 service for historical queries. 1191 ''' 1192 def __init__(self, accounts): 1193 self.accounts = accounts 1194 1195 def get(self, id, timeout=None): 1196 ''' 1197 Get reads one Account by ID. 1198 ''' 1199 return self.accounts.get(id, timeout=timeout) 1200 1201 def list(self, filter, *args, timeout=None): 1202 ''' 1203 List gets a list of Accounts matching a given set of criteria. 1204 ''' 1205 return self.accounts.list(filter, *args, timeout=timeout) 1206 1207 1208class AccountsHistory: 1209 ''' 1210 AccountsHistory records all changes to the state of an Account. 1211 See `strongdm.models.AccountHistory`. 1212 ''' 1213 def __init__(self, channel, client): 1214 self.parent = client 1215 self.stub = AccountsHistoryStub(channel) 1216 1217 def list(self, filter, *args, timeout=None): 1218 ''' 1219 List gets a list of AccountHistory records matching a given set of criteria. 1220 ''' 1221 deadline = None if timeout is None else time.time() + timeout 1222 req = AccountHistoryListRequest() 1223 req.meta.CopyFrom(ListRequestMetadata()) 1224 if self.parent.page_limit > 0: 1225 req.meta.limit = self.parent.page_limit 1226 if self.parent.snapshot_datetime is not None: 1227 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1228 1229 req.filter = plumbing.quote_filter_args(filter, *args) 1230 1231 def generator(svc, req): 1232 tries = 0 1233 while True: 1234 t = None if deadline is None else deadline - time.time() 1235 try: 1236 plumbing_response = svc.stub.List( 1237 req, 1238 metadata=svc.parent.get_metadata( 1239 'AccountsHistory.List', req), 1240 timeout=t) 1241 except Exception as e: 1242 if self.parent.shouldRetry(tries, e, deadline): 1243 tries += 1 1244 time.sleep( 1245 self.parent.exponentialBackoff(tries, deadline)) 1246 continue 1247 raise plumbing.convert_error_to_porcelain(e) from e 1248 tries = 0 1249 for plumbing_item in plumbing_response.history: 1250 yield plumbing.convert_account_history_to_porcelain( 1251 plumbing_item) 1252 if plumbing_response.meta.next_cursor == '': 1253 break 1254 req.meta.cursor = plumbing_response.meta.next_cursor 1255 1256 return generator(self, req) 1257 1258 1259class Activities: 1260 ''' 1261 An Activity is a record of an action taken against a strongDM deployment, e.g. 1262 a user creation, resource deletion, sso configuration change, etc. The Activities 1263 service is read-only. 1264 See `strongdm.models.Activity`. 1265 ''' 1266 def __init__(self, channel, client): 1267 self.parent = client 1268 self.stub = ActivitiesStub(channel) 1269 1270 def get(self, id, timeout=None): 1271 ''' 1272 Get reads one Activity by ID. 1273 ''' 1274 deadline = None if timeout is None else time.time() + timeout 1275 req = ActivityGetRequest() 1276 if self.parent.snapshot_datetime is not None: 1277 req.meta.CopyFrom(GetRequestMetadata()) 1278 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1279 1280 req.id = (id) 1281 tries = 0 1282 plumbing_response = None 1283 while True: 1284 t = None if deadline is None else deadline - time.time() 1285 try: 1286 plumbing_response = self.stub.Get( 1287 req, 1288 metadata=self.parent.get_metadata('Activities.Get', req), 1289 timeout=t) 1290 except Exception as e: 1291 if self.parent.shouldRetry(tries, e, deadline): 1292 tries += 1 1293 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1294 continue 1295 raise plumbing.convert_error_to_porcelain(e) from e 1296 break 1297 1298 resp = models.ActivityGetResponse() 1299 resp.activity = plumbing.convert_activity_to_porcelain( 1300 plumbing_response.activity) 1301 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1302 plumbing_response.meta) 1303 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1304 plumbing_response.rate_limit) 1305 return resp 1306 1307 def list(self, filter, *args, timeout=None): 1308 ''' 1309 List gets a list of Activities matching a given set of criteria. 1310 The 'before' and 'after' filters can be used to control the time 1311 range of the output activities. If not provided, one week of back 1312 of activities will be returned. 1313 ''' 1314 deadline = None if timeout is None else time.time() + timeout 1315 req = ActivityListRequest() 1316 req.meta.CopyFrom(ListRequestMetadata()) 1317 if self.parent.page_limit > 0: 1318 req.meta.limit = self.parent.page_limit 1319 if self.parent.snapshot_datetime is not None: 1320 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1321 1322 req.filter = plumbing.quote_filter_args(filter, *args) 1323 1324 def generator(svc, req): 1325 tries = 0 1326 while True: 1327 t = None if deadline is None else deadline - time.time() 1328 try: 1329 plumbing_response = svc.stub.List( 1330 req, 1331 metadata=svc.parent.get_metadata( 1332 'Activities.List', req), 1333 timeout=t) 1334 except Exception as e: 1335 if self.parent.shouldRetry(tries, e, deadline): 1336 tries += 1 1337 time.sleep( 1338 self.parent.exponentialBackoff(tries, deadline)) 1339 continue 1340 raise plumbing.convert_error_to_porcelain(e) from e 1341 tries = 0 1342 for plumbing_item in plumbing_response.activities: 1343 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1344 if plumbing_response.meta.next_cursor == '': 1345 break 1346 req.meta.cursor = plumbing_response.meta.next_cursor 1347 1348 return generator(self, req) 1349 1350 1351class ApprovalWorkflowApprovers: 1352 ''' 1353 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1354 See `strongdm.models.ApprovalWorkflowApprover`. 1355 ''' 1356 def __init__(self, channel, client): 1357 self.parent = client 1358 self.stub = ApprovalWorkflowApproversStub(channel) 1359 1360 def create(self, approval_workflow_approver, timeout=None): 1361 ''' 1362 Deprecated: Create creates a new approval workflow approver. 1363 ''' 1364 deadline = None if timeout is None else time.time() + timeout 1365 req = ApprovalWorkflowApproverCreateRequest() 1366 1367 if approval_workflow_approver is not None: 1368 req.approval_workflow_approver.CopyFrom( 1369 plumbing.convert_approval_workflow_approver_to_plumbing( 1370 approval_workflow_approver)) 1371 tries = 0 1372 plumbing_response = None 1373 while True: 1374 t = None if deadline is None else deadline - time.time() 1375 try: 1376 plumbing_response = self.stub.Create( 1377 req, 1378 metadata=self.parent.get_metadata( 1379 'ApprovalWorkflowApprovers.Create', req), 1380 timeout=t) 1381 except Exception as e: 1382 if self.parent.shouldRetry(tries, e, deadline): 1383 tries += 1 1384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1385 continue 1386 raise plumbing.convert_error_to_porcelain(e) from e 1387 break 1388 1389 resp = models.ApprovalWorkflowApproverCreateResponse() 1390 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1391 plumbing_response.approval_workflow_approver) 1392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1393 plumbing_response.rate_limit) 1394 return resp 1395 1396 def get(self, id, timeout=None): 1397 ''' 1398 Deprecated: Get reads one approval workflow approver by ID. 1399 ''' 1400 deadline = None if timeout is None else time.time() + timeout 1401 req = ApprovalWorkflowApproverGetRequest() 1402 if self.parent.snapshot_datetime is not None: 1403 req.meta.CopyFrom(GetRequestMetadata()) 1404 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1405 1406 req.id = (id) 1407 tries = 0 1408 plumbing_response = None 1409 while True: 1410 t = None if deadline is None else deadline - time.time() 1411 try: 1412 plumbing_response = self.stub.Get( 1413 req, 1414 metadata=self.parent.get_metadata( 1415 'ApprovalWorkflowApprovers.Get', req), 1416 timeout=t) 1417 except Exception as e: 1418 if self.parent.shouldRetry(tries, e, deadline): 1419 tries += 1 1420 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1421 continue 1422 raise plumbing.convert_error_to_porcelain(e) from e 1423 break 1424 1425 resp = models.ApprovalWorkflowApproverGetResponse() 1426 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1427 plumbing_response.approval_workflow_approver) 1428 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1429 plumbing_response.meta) 1430 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1431 plumbing_response.rate_limit) 1432 return resp 1433 1434 def delete(self, id, timeout=None): 1435 ''' 1436 Deprecated: Delete deletes an existing approval workflow approver. 1437 ''' 1438 deadline = None if timeout is None else time.time() + timeout 1439 req = ApprovalWorkflowApproverDeleteRequest() 1440 1441 req.id = (id) 1442 tries = 0 1443 plumbing_response = None 1444 while True: 1445 t = None if deadline is None else deadline - time.time() 1446 try: 1447 plumbing_response = self.stub.Delete( 1448 req, 1449 metadata=self.parent.get_metadata( 1450 'ApprovalWorkflowApprovers.Delete', req), 1451 timeout=t) 1452 except Exception as e: 1453 if self.parent.shouldRetry(tries, e, deadline): 1454 tries += 1 1455 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1456 continue 1457 raise plumbing.convert_error_to_porcelain(e) from e 1458 break 1459 1460 resp = models.ApprovalWorkflowApproverDeleteResponse() 1461 resp.id = (plumbing_response.id) 1462 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1463 plumbing_response.rate_limit) 1464 return resp 1465 1466 def list(self, filter, *args, timeout=None): 1467 ''' 1468 Deprecated: Lists existing approval workflow approvers. 1469 ''' 1470 deadline = None if timeout is None else time.time() + timeout 1471 req = ApprovalWorkflowApproverListRequest() 1472 req.meta.CopyFrom(ListRequestMetadata()) 1473 if self.parent.page_limit > 0: 1474 req.meta.limit = self.parent.page_limit 1475 if self.parent.snapshot_datetime is not None: 1476 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1477 1478 req.filter = plumbing.quote_filter_args(filter, *args) 1479 1480 def generator(svc, req): 1481 tries = 0 1482 while True: 1483 t = None if deadline is None else deadline - time.time() 1484 try: 1485 plumbing_response = svc.stub.List( 1486 req, 1487 metadata=svc.parent.get_metadata( 1488 'ApprovalWorkflowApprovers.List', req), 1489 timeout=t) 1490 except Exception as e: 1491 if self.parent.shouldRetry(tries, e, deadline): 1492 tries += 1 1493 time.sleep( 1494 self.parent.exponentialBackoff(tries, deadline)) 1495 continue 1496 raise plumbing.convert_error_to_porcelain(e) from e 1497 tries = 0 1498 for plumbing_item in plumbing_response.approval_workflow_approvers: 1499 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1500 plumbing_item) 1501 if plumbing_response.meta.next_cursor == '': 1502 break 1503 req.meta.cursor = plumbing_response.meta.next_cursor 1504 1505 return generator(self, req) 1506 1507 1508class SnapshotApprovalWorkflowApprovers: 1509 ''' 1510 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1511 service for historical queries. 1512 ''' 1513 def __init__(self, approval_workflow_approvers): 1514 self.approval_workflow_approvers = approval_workflow_approvers 1515 1516 def get(self, id, timeout=None): 1517 ''' 1518 Deprecated: Get reads one approval workflow approver by ID. 1519 ''' 1520 return self.approval_workflow_approvers.get(id, timeout=timeout) 1521 1522 def list(self, filter, *args, timeout=None): 1523 ''' 1524 Deprecated: Lists existing approval workflow approvers. 1525 ''' 1526 return self.approval_workflow_approvers.list(filter, 1527 *args, 1528 timeout=timeout) 1529 1530 1531class ApprovalWorkflowApproversHistory: 1532 ''' 1533 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1534 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1535 ''' 1536 def __init__(self, channel, client): 1537 self.parent = client 1538 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1539 1540 def list(self, filter, *args, timeout=None): 1541 ''' 1542 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1543 ''' 1544 deadline = None if timeout is None else time.time() + timeout 1545 req = ApprovalWorkflowApproverHistoryListRequest() 1546 req.meta.CopyFrom(ListRequestMetadata()) 1547 if self.parent.page_limit > 0: 1548 req.meta.limit = self.parent.page_limit 1549 if self.parent.snapshot_datetime is not None: 1550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1551 1552 req.filter = plumbing.quote_filter_args(filter, *args) 1553 1554 def generator(svc, req): 1555 tries = 0 1556 while True: 1557 t = None if deadline is None else deadline - time.time() 1558 try: 1559 plumbing_response = svc.stub.List( 1560 req, 1561 metadata=svc.parent.get_metadata( 1562 'ApprovalWorkflowApproversHistory.List', req), 1563 timeout=t) 1564 except Exception as e: 1565 if self.parent.shouldRetry(tries, e, deadline): 1566 tries += 1 1567 time.sleep( 1568 self.parent.exponentialBackoff(tries, deadline)) 1569 continue 1570 raise plumbing.convert_error_to_porcelain(e) from e 1571 tries = 0 1572 for plumbing_item in plumbing_response.history: 1573 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1574 plumbing_item) 1575 if plumbing_response.meta.next_cursor == '': 1576 break 1577 req.meta.cursor = plumbing_response.meta.next_cursor 1578 1579 return generator(self, req) 1580 1581 1582class ApprovalWorkflowSteps: 1583 ''' 1584 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1585 See `strongdm.models.ApprovalWorkflowStep`. 1586 ''' 1587 def __init__(self, channel, client): 1588 self.parent = client 1589 self.stub = ApprovalWorkflowStepsStub(channel) 1590 1591 def create(self, approval_workflow_step, timeout=None): 1592 ''' 1593 Deprecated: Create creates a new approval workflow step. 1594 ''' 1595 deadline = None if timeout is None else time.time() + timeout 1596 req = ApprovalWorkflowStepCreateRequest() 1597 1598 if approval_workflow_step is not None: 1599 req.approval_workflow_step.CopyFrom( 1600 plumbing.convert_approval_workflow_step_to_plumbing( 1601 approval_workflow_step)) 1602 tries = 0 1603 plumbing_response = None 1604 while True: 1605 t = None if deadline is None else deadline - time.time() 1606 try: 1607 plumbing_response = self.stub.Create( 1608 req, 1609 metadata=self.parent.get_metadata( 1610 'ApprovalWorkflowSteps.Create', req), 1611 timeout=t) 1612 except Exception as e: 1613 if self.parent.shouldRetry(tries, e, deadline): 1614 tries += 1 1615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1616 continue 1617 raise plumbing.convert_error_to_porcelain(e) from e 1618 break 1619 1620 resp = models.ApprovalWorkflowStepCreateResponse() 1621 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1622 plumbing_response.approval_workflow_step) 1623 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1624 plumbing_response.rate_limit) 1625 return resp 1626 1627 def get(self, id, timeout=None): 1628 ''' 1629 Deprecated: Get reads one approval workflow step by ID. 1630 ''' 1631 deadline = None if timeout is None else time.time() + timeout 1632 req = ApprovalWorkflowStepGetRequest() 1633 if self.parent.snapshot_datetime is not None: 1634 req.meta.CopyFrom(GetRequestMetadata()) 1635 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1636 1637 req.id = (id) 1638 tries = 0 1639 plumbing_response = None 1640 while True: 1641 t = None if deadline is None else deadline - time.time() 1642 try: 1643 plumbing_response = self.stub.Get( 1644 req, 1645 metadata=self.parent.get_metadata( 1646 'ApprovalWorkflowSteps.Get', req), 1647 timeout=t) 1648 except Exception as e: 1649 if self.parent.shouldRetry(tries, e, deadline): 1650 tries += 1 1651 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1652 continue 1653 raise plumbing.convert_error_to_porcelain(e) from e 1654 break 1655 1656 resp = models.ApprovalWorkflowStepGetResponse() 1657 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1658 plumbing_response.approval_workflow_step) 1659 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1660 plumbing_response.meta) 1661 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1662 plumbing_response.rate_limit) 1663 return resp 1664 1665 def delete(self, id, timeout=None): 1666 ''' 1667 Deprecated: Delete deletes an existing approval workflow step. 1668 ''' 1669 deadline = None if timeout is None else time.time() + timeout 1670 req = ApprovalWorkflowStepDeleteRequest() 1671 1672 req.id = (id) 1673 tries = 0 1674 plumbing_response = None 1675 while True: 1676 t = None if deadline is None else deadline - time.time() 1677 try: 1678 plumbing_response = self.stub.Delete( 1679 req, 1680 metadata=self.parent.get_metadata( 1681 'ApprovalWorkflowSteps.Delete', req), 1682 timeout=t) 1683 except Exception as e: 1684 if self.parent.shouldRetry(tries, e, deadline): 1685 tries += 1 1686 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1687 continue 1688 raise plumbing.convert_error_to_porcelain(e) from e 1689 break 1690 1691 resp = models.ApprovalWorkflowStepDeleteResponse() 1692 resp.id = (plumbing_response.id) 1693 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1694 plumbing_response.rate_limit) 1695 return resp 1696 1697 def list(self, filter, *args, timeout=None): 1698 ''' 1699 Deprecated: Lists existing approval workflow steps. 1700 ''' 1701 deadline = None if timeout is None else time.time() + timeout 1702 req = ApprovalWorkflowStepListRequest() 1703 req.meta.CopyFrom(ListRequestMetadata()) 1704 if self.parent.page_limit > 0: 1705 req.meta.limit = self.parent.page_limit 1706 if self.parent.snapshot_datetime is not None: 1707 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1708 1709 req.filter = plumbing.quote_filter_args(filter, *args) 1710 1711 def generator(svc, req): 1712 tries = 0 1713 while True: 1714 t = None if deadline is None else deadline - time.time() 1715 try: 1716 plumbing_response = svc.stub.List( 1717 req, 1718 metadata=svc.parent.get_metadata( 1719 'ApprovalWorkflowSteps.List', req), 1720 timeout=t) 1721 except Exception as e: 1722 if self.parent.shouldRetry(tries, e, deadline): 1723 tries += 1 1724 time.sleep( 1725 self.parent.exponentialBackoff(tries, deadline)) 1726 continue 1727 raise plumbing.convert_error_to_porcelain(e) from e 1728 tries = 0 1729 for plumbing_item in plumbing_response.approval_workflow_steps: 1730 yield plumbing.convert_approval_workflow_step_to_porcelain( 1731 plumbing_item) 1732 if plumbing_response.meta.next_cursor == '': 1733 break 1734 req.meta.cursor = plumbing_response.meta.next_cursor 1735 1736 return generator(self, req) 1737 1738 1739class SnapshotApprovalWorkflowSteps: 1740 ''' 1741 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1742 service for historical queries. 1743 ''' 1744 def __init__(self, approval_workflow_steps): 1745 self.approval_workflow_steps = approval_workflow_steps 1746 1747 def get(self, id, timeout=None): 1748 ''' 1749 Deprecated: Get reads one approval workflow step by ID. 1750 ''' 1751 return self.approval_workflow_steps.get(id, timeout=timeout) 1752 1753 def list(self, filter, *args, timeout=None): 1754 ''' 1755 Deprecated: Lists existing approval workflow steps. 1756 ''' 1757 return self.approval_workflow_steps.list(filter, 1758 *args, 1759 timeout=timeout) 1760 1761 1762class ApprovalWorkflowStepsHistory: 1763 ''' 1764 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 1765 See `strongdm.models.ApprovalWorkflowStepHistory`. 1766 ''' 1767 def __init__(self, channel, client): 1768 self.parent = client 1769 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 1770 1771 def list(self, filter, *args, timeout=None): 1772 ''' 1773 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1774 ''' 1775 deadline = None if timeout is None else time.time() + timeout 1776 req = ApprovalWorkflowStepHistoryListRequest() 1777 req.meta.CopyFrom(ListRequestMetadata()) 1778 if self.parent.page_limit > 0: 1779 req.meta.limit = self.parent.page_limit 1780 if self.parent.snapshot_datetime is not None: 1781 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1782 1783 req.filter = plumbing.quote_filter_args(filter, *args) 1784 1785 def generator(svc, req): 1786 tries = 0 1787 while True: 1788 t = None if deadline is None else deadline - time.time() 1789 try: 1790 plumbing_response = svc.stub.List( 1791 req, 1792 metadata=svc.parent.get_metadata( 1793 'ApprovalWorkflowStepsHistory.List', req), 1794 timeout=t) 1795 except Exception as e: 1796 if self.parent.shouldRetry(tries, e, deadline): 1797 tries += 1 1798 time.sleep( 1799 self.parent.exponentialBackoff(tries, deadline)) 1800 continue 1801 raise plumbing.convert_error_to_porcelain(e) from e 1802 tries = 0 1803 for plumbing_item in plumbing_response.history: 1804 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1805 plumbing_item) 1806 if plumbing_response.meta.next_cursor == '': 1807 break 1808 req.meta.cursor = plumbing_response.meta.next_cursor 1809 1810 return generator(self, req) 1811 1812 1813class ApprovalWorkflows: 1814 ''' 1815 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 1816 approvers and be approved or denied. 1817 See `strongdm.models.ApprovalWorkflow`. 1818 ''' 1819 def __init__(self, channel, client): 1820 self.parent = client 1821 self.stub = ApprovalWorkflowsStub(channel) 1822 1823 def create(self, approval_workflow, timeout=None): 1824 ''' 1825 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1826 ''' 1827 deadline = None if timeout is None else time.time() + timeout 1828 req = ApprovalWorkflowCreateRequest() 1829 1830 if approval_workflow is not None: 1831 req.approval_workflow.CopyFrom( 1832 plumbing.convert_approval_workflow_to_plumbing( 1833 approval_workflow)) 1834 tries = 0 1835 plumbing_response = None 1836 while True: 1837 t = None if deadline is None else deadline - time.time() 1838 try: 1839 plumbing_response = self.stub.Create( 1840 req, 1841 metadata=self.parent.get_metadata( 1842 'ApprovalWorkflows.Create', req), 1843 timeout=t) 1844 except Exception as e: 1845 if self.parent.shouldRetry(tries, e, deadline): 1846 tries += 1 1847 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1848 continue 1849 raise plumbing.convert_error_to_porcelain(e) from e 1850 break 1851 1852 resp = models.ApprovalWorkflowCreateResponse() 1853 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1854 plumbing_response.approval_workflow) 1855 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1856 plumbing_response.rate_limit) 1857 return resp 1858 1859 def get(self, id, timeout=None): 1860 ''' 1861 Get reads one approval workflow by ID. 1862 ''' 1863 deadline = None if timeout is None else time.time() + timeout 1864 req = ApprovalWorkflowGetRequest() 1865 if self.parent.snapshot_datetime is not None: 1866 req.meta.CopyFrom(GetRequestMetadata()) 1867 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1868 1869 req.id = (id) 1870 tries = 0 1871 plumbing_response = None 1872 while True: 1873 t = None if deadline is None else deadline - time.time() 1874 try: 1875 plumbing_response = self.stub.Get( 1876 req, 1877 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1878 req), 1879 timeout=t) 1880 except Exception as e: 1881 if self.parent.shouldRetry(tries, e, deadline): 1882 tries += 1 1883 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1884 continue 1885 raise plumbing.convert_error_to_porcelain(e) from e 1886 break 1887 1888 resp = models.ApprovalWorkflowGetResponse() 1889 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1890 plumbing_response.approval_workflow) 1891 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1892 plumbing_response.meta) 1893 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1894 plumbing_response.rate_limit) 1895 return resp 1896 1897 def delete(self, id, timeout=None): 1898 ''' 1899 Delete deletes an existing approval workflow. 1900 ''' 1901 deadline = None if timeout is None else time.time() + timeout 1902 req = ApprovalWorkflowDeleteRequest() 1903 1904 req.id = (id) 1905 tries = 0 1906 plumbing_response = None 1907 while True: 1908 t = None if deadline is None else deadline - time.time() 1909 try: 1910 plumbing_response = self.stub.Delete( 1911 req, 1912 metadata=self.parent.get_metadata( 1913 'ApprovalWorkflows.Delete', req), 1914 timeout=t) 1915 except Exception as e: 1916 if self.parent.shouldRetry(tries, e, deadline): 1917 tries += 1 1918 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1919 continue 1920 raise plumbing.convert_error_to_porcelain(e) from e 1921 break 1922 1923 resp = models.ApprovalWorkflowDeleteResponse() 1924 resp.id = (plumbing_response.id) 1925 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1926 plumbing_response.rate_limit) 1927 return resp 1928 1929 def update(self, approval_workflow, timeout=None): 1930 ''' 1931 Update updates an existing approval workflow. 1932 ''' 1933 deadline = None if timeout is None else time.time() + timeout 1934 req = ApprovalWorkflowUpdateRequest() 1935 1936 if approval_workflow is not None: 1937 req.approval_workflow.CopyFrom( 1938 plumbing.convert_approval_workflow_to_plumbing( 1939 approval_workflow)) 1940 tries = 0 1941 plumbing_response = None 1942 while True: 1943 t = None if deadline is None else deadline - time.time() 1944 try: 1945 plumbing_response = self.stub.Update( 1946 req, 1947 metadata=self.parent.get_metadata( 1948 'ApprovalWorkflows.Update', req), 1949 timeout=t) 1950 except Exception as e: 1951 if self.parent.shouldRetry(tries, e, deadline): 1952 tries += 1 1953 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1954 continue 1955 raise plumbing.convert_error_to_porcelain(e) from e 1956 break 1957 1958 resp = models.ApprovalWorkflowUpdateResponse() 1959 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1960 plumbing_response.approval_workflow) 1961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1962 plumbing_response.rate_limit) 1963 return resp 1964 1965 def list(self, filter, *args, timeout=None): 1966 ''' 1967 Lists existing approval workflows. 1968 ''' 1969 deadline = None if timeout is None else time.time() + timeout 1970 req = ApprovalWorkflowListRequest() 1971 req.meta.CopyFrom(ListRequestMetadata()) 1972 if self.parent.page_limit > 0: 1973 req.meta.limit = self.parent.page_limit 1974 if self.parent.snapshot_datetime is not None: 1975 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1976 1977 req.filter = plumbing.quote_filter_args(filter, *args) 1978 1979 def generator(svc, req): 1980 tries = 0 1981 while True: 1982 t = None if deadline is None else deadline - time.time() 1983 try: 1984 plumbing_response = svc.stub.List( 1985 req, 1986 metadata=svc.parent.get_metadata( 1987 'ApprovalWorkflows.List', req), 1988 timeout=t) 1989 except Exception as e: 1990 if self.parent.shouldRetry(tries, e, deadline): 1991 tries += 1 1992 time.sleep( 1993 self.parent.exponentialBackoff(tries, deadline)) 1994 continue 1995 raise plumbing.convert_error_to_porcelain(e) from e 1996 tries = 0 1997 for plumbing_item in plumbing_response.approval_workflows: 1998 yield plumbing.convert_approval_workflow_to_porcelain( 1999 plumbing_item) 2000 if plumbing_response.meta.next_cursor == '': 2001 break 2002 req.meta.cursor = plumbing_response.meta.next_cursor 2003 2004 return generator(self, req) 2005 2006 2007class SnapshotApprovalWorkflows: 2008 ''' 2009 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2010 service for historical queries. 2011 ''' 2012 def __init__(self, approval_workflows): 2013 self.approval_workflows = approval_workflows 2014 2015 def get(self, id, timeout=None): 2016 ''' 2017 Get reads one approval workflow by ID. 2018 ''' 2019 return self.approval_workflows.get(id, timeout=timeout) 2020 2021 def list(self, filter, *args, timeout=None): 2022 ''' 2023 Lists existing approval workflows. 2024 ''' 2025 return self.approval_workflows.list(filter, *args, timeout=timeout) 2026 2027 2028class ApprovalWorkflowsHistory: 2029 ''' 2030 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2031 See `strongdm.models.ApprovalWorkflowHistory`. 2032 ''' 2033 def __init__(self, channel, client): 2034 self.parent = client 2035 self.stub = ApprovalWorkflowsHistoryStub(channel) 2036 2037 def list(self, filter, *args, timeout=None): 2038 ''' 2039 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2040 ''' 2041 deadline = None if timeout is None else time.time() + timeout 2042 req = ApprovalWorkflowHistoryListRequest() 2043 req.meta.CopyFrom(ListRequestMetadata()) 2044 if self.parent.page_limit > 0: 2045 req.meta.limit = self.parent.page_limit 2046 if self.parent.snapshot_datetime is not None: 2047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2048 2049 req.filter = plumbing.quote_filter_args(filter, *args) 2050 2051 def generator(svc, req): 2052 tries = 0 2053 while True: 2054 t = None if deadline is None else deadline - time.time() 2055 try: 2056 plumbing_response = svc.stub.List( 2057 req, 2058 metadata=svc.parent.get_metadata( 2059 'ApprovalWorkflowsHistory.List', req), 2060 timeout=t) 2061 except Exception as e: 2062 if self.parent.shouldRetry(tries, e, deadline): 2063 tries += 1 2064 time.sleep( 2065 self.parent.exponentialBackoff(tries, deadline)) 2066 continue 2067 raise plumbing.convert_error_to_porcelain(e) from e 2068 tries = 0 2069 for plumbing_item in plumbing_response.history: 2070 yield plumbing.convert_approval_workflow_history_to_porcelain( 2071 plumbing_item) 2072 if plumbing_response.meta.next_cursor == '': 2073 break 2074 req.meta.cursor = plumbing_response.meta.next_cursor 2075 2076 return generator(self, req) 2077 2078 2079class ControlPanel: 2080 ''' 2081 ControlPanel contains all administrative controls. 2082 ''' 2083 def __init__(self, channel, client): 2084 self.parent = client 2085 self.stub = ControlPanelStub(channel) 2086 2087 def get_sshca_public_key(self, timeout=None): 2088 ''' 2089 GetSSHCAPublicKey retrieves the SSH CA public key. 2090 ''' 2091 deadline = None if timeout is None else time.time() + timeout 2092 req = ControlPanelGetSSHCAPublicKeyRequest() 2093 2094 tries = 0 2095 plumbing_response = None 2096 while True: 2097 t = None if deadline is None else deadline - time.time() 2098 try: 2099 plumbing_response = self.stub.GetSSHCAPublicKey( 2100 req, 2101 metadata=self.parent.get_metadata( 2102 'ControlPanel.GetSSHCAPublicKey', req), 2103 timeout=t) 2104 except Exception as e: 2105 if self.parent.shouldRetry(tries, e, deadline): 2106 tries += 1 2107 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2108 continue 2109 raise plumbing.convert_error_to_porcelain(e) from e 2110 break 2111 2112 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2113 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2114 plumbing_response.meta) 2115 resp.public_key = (plumbing_response.public_key) 2116 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2117 plumbing_response.rate_limit) 2118 return resp 2119 2120 def get_rdpca_public_key(self, timeout=None): 2121 ''' 2122 GetRDPCAPublicKey retrieves the RDP CA public key. 2123 ''' 2124 deadline = None if timeout is None else time.time() + timeout 2125 req = ControlPanelGetRDPCAPublicKeyRequest() 2126 2127 tries = 0 2128 plumbing_response = None 2129 while True: 2130 t = None if deadline is None else deadline - time.time() 2131 try: 2132 plumbing_response = self.stub.GetRDPCAPublicKey( 2133 req, 2134 metadata=self.parent.get_metadata( 2135 'ControlPanel.GetRDPCAPublicKey', req), 2136 timeout=t) 2137 except Exception as e: 2138 if self.parent.shouldRetry(tries, e, deadline): 2139 tries += 1 2140 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2141 continue 2142 raise plumbing.convert_error_to_porcelain(e) from e 2143 break 2144 2145 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2146 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2147 plumbing_response.meta) 2148 resp.public_key = (plumbing_response.public_key) 2149 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2150 plumbing_response.rate_limit) 2151 return resp 2152 2153 def verify_jwt(self, token, timeout=None): 2154 ''' 2155 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2156 ''' 2157 deadline = None if timeout is None else time.time() + timeout 2158 req = ControlPanelVerifyJWTRequest() 2159 2160 req.token = (token) 2161 tries = 0 2162 plumbing_response = None 2163 while True: 2164 t = None if deadline is None else deadline - time.time() 2165 try: 2166 plumbing_response = self.stub.VerifyJWT( 2167 req, 2168 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2169 req), 2170 timeout=t) 2171 except Exception as e: 2172 if self.parent.shouldRetry(tries, e, deadline): 2173 tries += 1 2174 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2175 continue 2176 raise plumbing.convert_error_to_porcelain(e) from e 2177 break 2178 2179 resp = models.ControlPanelVerifyJWTResponse() 2180 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2181 plumbing_response.meta) 2182 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2183 plumbing_response.rate_limit) 2184 resp.valid = (plumbing_response.valid) 2185 return resp 2186 2187 2188class HealthChecks: 2189 ''' 2190 HealthChecks lists the last healthcheck between each node and resource. 2191 Note the unconventional capitalization here is to prevent having a collision with GRPC 2192 See `strongdm.models.Healthcheck`. 2193 ''' 2194 def __init__(self, channel, client): 2195 self.parent = client 2196 self.stub = HealthChecksStub(channel) 2197 2198 def list(self, filter, *args, timeout=None): 2199 ''' 2200 List gets a list of Healthchecks matching a given set of criteria. 2201 ''' 2202 deadline = None if timeout is None else time.time() + timeout 2203 req = HealthcheckListRequest() 2204 req.meta.CopyFrom(ListRequestMetadata()) 2205 if self.parent.page_limit > 0: 2206 req.meta.limit = self.parent.page_limit 2207 if self.parent.snapshot_datetime is not None: 2208 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2209 2210 req.filter = plumbing.quote_filter_args(filter, *args) 2211 2212 def generator(svc, req): 2213 tries = 0 2214 while True: 2215 t = None if deadline is None else deadline - time.time() 2216 try: 2217 plumbing_response = svc.stub.List( 2218 req, 2219 metadata=svc.parent.get_metadata( 2220 'HealthChecks.List', req), 2221 timeout=t) 2222 except Exception as e: 2223 if self.parent.shouldRetry(tries, e, deadline): 2224 tries += 1 2225 time.sleep( 2226 self.parent.exponentialBackoff(tries, deadline)) 2227 continue 2228 raise plumbing.convert_error_to_porcelain(e) from e 2229 tries = 0 2230 for plumbing_item in plumbing_response.healthchecks: 2231 yield plumbing.convert_healthcheck_to_porcelain( 2232 plumbing_item) 2233 if plumbing_response.meta.next_cursor == '': 2234 break 2235 req.meta.cursor = plumbing_response.meta.next_cursor 2236 2237 return generator(self, req) 2238 2239 2240class IdentityAliases: 2241 ''' 2242 IdentityAliases assign an alias to an account within an IdentitySet. 2243 The alias is used as the username when connecting to a identity supported resource. 2244 See `strongdm.models.IdentityAlias`. 2245 ''' 2246 def __init__(self, channel, client): 2247 self.parent = client 2248 self.stub = IdentityAliasesStub(channel) 2249 2250 def create(self, identity_alias, timeout=None): 2251 ''' 2252 Create registers a new IdentityAlias. 2253 ''' 2254 deadline = None if timeout is None else time.time() + timeout 2255 req = IdentityAliasCreateRequest() 2256 2257 if identity_alias is not None: 2258 req.identity_alias.CopyFrom( 2259 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2260 tries = 0 2261 plumbing_response = None 2262 while True: 2263 t = None if deadline is None else deadline - time.time() 2264 try: 2265 plumbing_response = self.stub.Create( 2266 req, 2267 metadata=self.parent.get_metadata('IdentityAliases.Create', 2268 req), 2269 timeout=t) 2270 except Exception as e: 2271 if self.parent.shouldRetry(tries, e, deadline): 2272 tries += 1 2273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2274 continue 2275 raise plumbing.convert_error_to_porcelain(e) from e 2276 break 2277 2278 resp = models.IdentityAliasCreateResponse() 2279 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2280 plumbing_response.identity_alias) 2281 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2282 plumbing_response.meta) 2283 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2284 plumbing_response.rate_limit) 2285 return resp 2286 2287 def get(self, id, timeout=None): 2288 ''' 2289 Get reads one IdentityAlias by ID. 2290 ''' 2291 deadline = None if timeout is None else time.time() + timeout 2292 req = IdentityAliasGetRequest() 2293 if self.parent.snapshot_datetime is not None: 2294 req.meta.CopyFrom(GetRequestMetadata()) 2295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2296 2297 req.id = (id) 2298 tries = 0 2299 plumbing_response = None 2300 while True: 2301 t = None if deadline is None else deadline - time.time() 2302 try: 2303 plumbing_response = self.stub.Get( 2304 req, 2305 metadata=self.parent.get_metadata('IdentityAliases.Get', 2306 req), 2307 timeout=t) 2308 except Exception as e: 2309 if self.parent.shouldRetry(tries, e, deadline): 2310 tries += 1 2311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2312 continue 2313 raise plumbing.convert_error_to_porcelain(e) from e 2314 break 2315 2316 resp = models.IdentityAliasGetResponse() 2317 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2318 plumbing_response.identity_alias) 2319 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2320 plumbing_response.meta) 2321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2322 plumbing_response.rate_limit) 2323 return resp 2324 2325 def update(self, identity_alias, timeout=None): 2326 ''' 2327 Update replaces all the fields of a IdentityAlias by ID. 2328 ''' 2329 deadline = None if timeout is None else time.time() + timeout 2330 req = IdentityAliasUpdateRequest() 2331 2332 if identity_alias is not None: 2333 req.identity_alias.CopyFrom( 2334 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2335 tries = 0 2336 plumbing_response = None 2337 while True: 2338 t = None if deadline is None else deadline - time.time() 2339 try: 2340 plumbing_response = self.stub.Update( 2341 req, 2342 metadata=self.parent.get_metadata('IdentityAliases.Update', 2343 req), 2344 timeout=t) 2345 except Exception as e: 2346 if self.parent.shouldRetry(tries, e, deadline): 2347 tries += 1 2348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2349 continue 2350 raise plumbing.convert_error_to_porcelain(e) from e 2351 break 2352 2353 resp = models.IdentityAliasUpdateResponse() 2354 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2355 plumbing_response.identity_alias) 2356 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2357 plumbing_response.meta) 2358 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2359 plumbing_response.rate_limit) 2360 return resp 2361 2362 def delete(self, id, timeout=None): 2363 ''' 2364 Delete removes a IdentityAlias by ID. 2365 ''' 2366 deadline = None if timeout is None else time.time() + timeout 2367 req = IdentityAliasDeleteRequest() 2368 2369 req.id = (id) 2370 tries = 0 2371 plumbing_response = None 2372 while True: 2373 t = None if deadline is None else deadline - time.time() 2374 try: 2375 plumbing_response = self.stub.Delete( 2376 req, 2377 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2378 req), 2379 timeout=t) 2380 except Exception as e: 2381 if self.parent.shouldRetry(tries, e, deadline): 2382 tries += 1 2383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2384 continue 2385 raise plumbing.convert_error_to_porcelain(e) from e 2386 break 2387 2388 resp = models.IdentityAliasDeleteResponse() 2389 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2390 plumbing_response.meta) 2391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2392 plumbing_response.rate_limit) 2393 return resp 2394 2395 def list(self, filter, *args, timeout=None): 2396 ''' 2397 List gets a list of IdentityAliases matching a given set of criteria. 2398 ''' 2399 deadline = None if timeout is None else time.time() + timeout 2400 req = IdentityAliasListRequest() 2401 req.meta.CopyFrom(ListRequestMetadata()) 2402 if self.parent.page_limit > 0: 2403 req.meta.limit = self.parent.page_limit 2404 if self.parent.snapshot_datetime is not None: 2405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2406 2407 req.filter = plumbing.quote_filter_args(filter, *args) 2408 2409 def generator(svc, req): 2410 tries = 0 2411 while True: 2412 t = None if deadline is None else deadline - time.time() 2413 try: 2414 plumbing_response = svc.stub.List( 2415 req, 2416 metadata=svc.parent.get_metadata( 2417 'IdentityAliases.List', req), 2418 timeout=t) 2419 except Exception as e: 2420 if self.parent.shouldRetry(tries, e, deadline): 2421 tries += 1 2422 time.sleep( 2423 self.parent.exponentialBackoff(tries, deadline)) 2424 continue 2425 raise plumbing.convert_error_to_porcelain(e) from e 2426 tries = 0 2427 for plumbing_item in plumbing_response.identity_aliases: 2428 yield plumbing.convert_identity_alias_to_porcelain( 2429 plumbing_item) 2430 if plumbing_response.meta.next_cursor == '': 2431 break 2432 req.meta.cursor = plumbing_response.meta.next_cursor 2433 2434 return generator(self, req) 2435 2436 2437class SnapshotIdentityAliases: 2438 ''' 2439 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2440 service for historical queries. 2441 ''' 2442 def __init__(self, identity_aliases): 2443 self.identity_aliases = identity_aliases 2444 2445 def get(self, id, timeout=None): 2446 ''' 2447 Get reads one IdentityAlias by ID. 2448 ''' 2449 return self.identity_aliases.get(id, timeout=timeout) 2450 2451 def list(self, filter, *args, timeout=None): 2452 ''' 2453 List gets a list of IdentityAliases matching a given set of criteria. 2454 ''' 2455 return self.identity_aliases.list(filter, *args, timeout=timeout) 2456 2457 2458class IdentityAliasesHistory: 2459 ''' 2460 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2461 See `strongdm.models.IdentityAliasHistory`. 2462 ''' 2463 def __init__(self, channel, client): 2464 self.parent = client 2465 self.stub = IdentityAliasesHistoryStub(channel) 2466 2467 def list(self, filter, *args, timeout=None): 2468 ''' 2469 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2470 ''' 2471 deadline = None if timeout is None else time.time() + timeout 2472 req = IdentityAliasHistoryListRequest() 2473 req.meta.CopyFrom(ListRequestMetadata()) 2474 if self.parent.page_limit > 0: 2475 req.meta.limit = self.parent.page_limit 2476 if self.parent.snapshot_datetime is not None: 2477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2478 2479 req.filter = plumbing.quote_filter_args(filter, *args) 2480 2481 def generator(svc, req): 2482 tries = 0 2483 while True: 2484 t = None if deadline is None else deadline - time.time() 2485 try: 2486 plumbing_response = svc.stub.List( 2487 req, 2488 metadata=svc.parent.get_metadata( 2489 'IdentityAliasesHistory.List', req), 2490 timeout=t) 2491 except Exception as e: 2492 if self.parent.shouldRetry(tries, e, deadline): 2493 tries += 1 2494 time.sleep( 2495 self.parent.exponentialBackoff(tries, deadline)) 2496 continue 2497 raise plumbing.convert_error_to_porcelain(e) from e 2498 tries = 0 2499 for plumbing_item in plumbing_response.history: 2500 yield plumbing.convert_identity_alias_history_to_porcelain( 2501 plumbing_item) 2502 if plumbing_response.meta.next_cursor == '': 2503 break 2504 req.meta.cursor = plumbing_response.meta.next_cursor 2505 2506 return generator(self, req) 2507 2508 2509class IdentitySets: 2510 ''' 2511 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2512 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2513 See `strongdm.models.IdentitySet`. 2514 ''' 2515 def __init__(self, channel, client): 2516 self.parent = client 2517 self.stub = IdentitySetsStub(channel) 2518 2519 def create(self, identity_set, timeout=None): 2520 ''' 2521 Create registers a new IdentitySet. 2522 ''' 2523 deadline = None if timeout is None else time.time() + timeout 2524 req = IdentitySetCreateRequest() 2525 2526 if identity_set is not None: 2527 req.identity_set.CopyFrom( 2528 plumbing.convert_identity_set_to_plumbing(identity_set)) 2529 tries = 0 2530 plumbing_response = None 2531 while True: 2532 t = None if deadline is None else deadline - time.time() 2533 try: 2534 plumbing_response = self.stub.Create( 2535 req, 2536 metadata=self.parent.get_metadata('IdentitySets.Create', 2537 req), 2538 timeout=t) 2539 except Exception as e: 2540 if self.parent.shouldRetry(tries, e, deadline): 2541 tries += 1 2542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2543 continue 2544 raise plumbing.convert_error_to_porcelain(e) from e 2545 break 2546 2547 resp = models.IdentitySetCreateResponse() 2548 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2549 plumbing_response.identity_set) 2550 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2551 plumbing_response.meta) 2552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2553 plumbing_response.rate_limit) 2554 return resp 2555 2556 def get(self, id, timeout=None): 2557 ''' 2558 Get reads one IdentitySet by ID. 2559 ''' 2560 deadline = None if timeout is None else time.time() + timeout 2561 req = IdentitySetGetRequest() 2562 if self.parent.snapshot_datetime is not None: 2563 req.meta.CopyFrom(GetRequestMetadata()) 2564 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2565 2566 req.id = (id) 2567 tries = 0 2568 plumbing_response = None 2569 while True: 2570 t = None if deadline is None else deadline - time.time() 2571 try: 2572 plumbing_response = self.stub.Get( 2573 req, 2574 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2575 timeout=t) 2576 except Exception as e: 2577 if self.parent.shouldRetry(tries, e, deadline): 2578 tries += 1 2579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2580 continue 2581 raise plumbing.convert_error_to_porcelain(e) from e 2582 break 2583 2584 resp = models.IdentitySetGetResponse() 2585 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2586 plumbing_response.identity_set) 2587 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2588 plumbing_response.meta) 2589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2590 plumbing_response.rate_limit) 2591 return resp 2592 2593 def update(self, identity_set, timeout=None): 2594 ''' 2595 Update replaces all the fields of a IdentitySet by ID. 2596 ''' 2597 deadline = None if timeout is None else time.time() + timeout 2598 req = IdentitySetUpdateRequest() 2599 2600 if identity_set is not None: 2601 req.identity_set.CopyFrom( 2602 plumbing.convert_identity_set_to_plumbing(identity_set)) 2603 tries = 0 2604 plumbing_response = None 2605 while True: 2606 t = None if deadline is None else deadline - time.time() 2607 try: 2608 plumbing_response = self.stub.Update( 2609 req, 2610 metadata=self.parent.get_metadata('IdentitySets.Update', 2611 req), 2612 timeout=t) 2613 except Exception as e: 2614 if self.parent.shouldRetry(tries, e, deadline): 2615 tries += 1 2616 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2617 continue 2618 raise plumbing.convert_error_to_porcelain(e) from e 2619 break 2620 2621 resp = models.IdentitySetUpdateResponse() 2622 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2623 plumbing_response.identity_set) 2624 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2625 plumbing_response.meta) 2626 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2627 plumbing_response.rate_limit) 2628 return resp 2629 2630 def delete(self, id, timeout=None): 2631 ''' 2632 Delete removes a IdentitySet by ID. 2633 ''' 2634 deadline = None if timeout is None else time.time() + timeout 2635 req = IdentitySetDeleteRequest() 2636 2637 req.id = (id) 2638 tries = 0 2639 plumbing_response = None 2640 while True: 2641 t = None if deadline is None else deadline - time.time() 2642 try: 2643 plumbing_response = self.stub.Delete( 2644 req, 2645 metadata=self.parent.get_metadata('IdentitySets.Delete', 2646 req), 2647 timeout=t) 2648 except Exception as e: 2649 if self.parent.shouldRetry(tries, e, deadline): 2650 tries += 1 2651 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2652 continue 2653 raise plumbing.convert_error_to_porcelain(e) from e 2654 break 2655 2656 resp = models.IdentitySetDeleteResponse() 2657 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2658 plumbing_response.meta) 2659 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2660 plumbing_response.rate_limit) 2661 return resp 2662 2663 def list(self, filter, *args, timeout=None): 2664 ''' 2665 List gets a list of IdentitySets matching a given set of criteria. 2666 ''' 2667 deadline = None if timeout is None else time.time() + timeout 2668 req = IdentitySetListRequest() 2669 req.meta.CopyFrom(ListRequestMetadata()) 2670 if self.parent.page_limit > 0: 2671 req.meta.limit = self.parent.page_limit 2672 if self.parent.snapshot_datetime is not None: 2673 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2674 2675 req.filter = plumbing.quote_filter_args(filter, *args) 2676 2677 def generator(svc, req): 2678 tries = 0 2679 while True: 2680 t = None if deadline is None else deadline - time.time() 2681 try: 2682 plumbing_response = svc.stub.List( 2683 req, 2684 metadata=svc.parent.get_metadata( 2685 'IdentitySets.List', req), 2686 timeout=t) 2687 except Exception as e: 2688 if self.parent.shouldRetry(tries, e, deadline): 2689 tries += 1 2690 time.sleep( 2691 self.parent.exponentialBackoff(tries, deadline)) 2692 continue 2693 raise plumbing.convert_error_to_porcelain(e) from e 2694 tries = 0 2695 for plumbing_item in plumbing_response.identity_sets: 2696 yield plumbing.convert_identity_set_to_porcelain( 2697 plumbing_item) 2698 if plumbing_response.meta.next_cursor == '': 2699 break 2700 req.meta.cursor = plumbing_response.meta.next_cursor 2701 2702 return generator(self, req) 2703 2704 2705class SnapshotIdentitySets: 2706 ''' 2707 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2708 service for historical queries. 2709 ''' 2710 def __init__(self, identity_sets): 2711 self.identity_sets = identity_sets 2712 2713 def get(self, id, timeout=None): 2714 ''' 2715 Get reads one IdentitySet by ID. 2716 ''' 2717 return self.identity_sets.get(id, timeout=timeout) 2718 2719 def list(self, filter, *args, timeout=None): 2720 ''' 2721 List gets a list of IdentitySets matching a given set of criteria. 2722 ''' 2723 return self.identity_sets.list(filter, *args, timeout=timeout) 2724 2725 2726class IdentitySetsHistory: 2727 ''' 2728 IdentitySetsHistory records all changes to the state of a IdentitySet. 2729 See `strongdm.models.IdentitySetHistory`. 2730 ''' 2731 def __init__(self, channel, client): 2732 self.parent = client 2733 self.stub = IdentitySetsHistoryStub(channel) 2734 2735 def list(self, filter, *args, timeout=None): 2736 ''' 2737 List gets a list of IdentitySetHistory records matching a given set of criteria. 2738 ''' 2739 deadline = None if timeout is None else time.time() + timeout 2740 req = IdentitySetHistoryListRequest() 2741 req.meta.CopyFrom(ListRequestMetadata()) 2742 if self.parent.page_limit > 0: 2743 req.meta.limit = self.parent.page_limit 2744 if self.parent.snapshot_datetime is not None: 2745 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2746 2747 req.filter = plumbing.quote_filter_args(filter, *args) 2748 2749 def generator(svc, req): 2750 tries = 0 2751 while True: 2752 t = None if deadline is None else deadline - time.time() 2753 try: 2754 plumbing_response = svc.stub.List( 2755 req, 2756 metadata=svc.parent.get_metadata( 2757 'IdentitySetsHistory.List', req), 2758 timeout=t) 2759 except Exception as e: 2760 if self.parent.shouldRetry(tries, e, deadline): 2761 tries += 1 2762 time.sleep( 2763 self.parent.exponentialBackoff(tries, deadline)) 2764 continue 2765 raise plumbing.convert_error_to_porcelain(e) from e 2766 tries = 0 2767 for plumbing_item in plumbing_response.history: 2768 yield plumbing.convert_identity_set_history_to_porcelain( 2769 plumbing_item) 2770 if plumbing_response.meta.next_cursor == '': 2771 break 2772 req.meta.cursor = plumbing_response.meta.next_cursor 2773 2774 return generator(self, req) 2775 2776 2777class ManagedSecrets: 2778 ''' 2779 ManagedSecret is a private vertical for creating, reading, updating, 2780 deleting, listing and rotating the managed secrets in the secrets engines as 2781 an authenticated user. 2782 See `strongdm.models.ManagedSecret`. 2783 ''' 2784 def __init__(self, channel, client): 2785 self.parent = client 2786 self.stub = ManagedSecretsStub(channel) 2787 2788 def list(self, filter, *args, timeout=None): 2789 ''' 2790 List returns Managed Secrets from a Secret Engine. 2791 ''' 2792 deadline = None if timeout is None else time.time() + timeout 2793 req = ManagedSecretListRequest() 2794 req.meta.CopyFrom(ListRequestMetadata()) 2795 if self.parent.page_limit > 0: 2796 req.meta.limit = self.parent.page_limit 2797 if self.parent.snapshot_datetime is not None: 2798 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2799 2800 req.filter = plumbing.quote_filter_args(filter, *args) 2801 2802 def generator(svc, req): 2803 tries = 0 2804 while True: 2805 t = None if deadline is None else deadline - time.time() 2806 try: 2807 plumbing_response = svc.stub.List( 2808 req, 2809 metadata=svc.parent.get_metadata( 2810 'ManagedSecrets.List', req), 2811 timeout=t) 2812 except Exception as e: 2813 if self.parent.shouldRetry(tries, e, deadline): 2814 tries += 1 2815 time.sleep( 2816 self.parent.exponentialBackoff(tries, deadline)) 2817 continue 2818 raise plumbing.convert_error_to_porcelain(e) from e 2819 tries = 0 2820 for plumbing_item in plumbing_response.managed_secrets: 2821 yield plumbing.convert_managed_secret_to_porcelain( 2822 plumbing_item) 2823 if plumbing_response.meta.next_cursor == '': 2824 break 2825 req.meta.cursor = plumbing_response.meta.next_cursor 2826 2827 return generator(self, req) 2828 2829 def list_by_actor(self, filter, *args, timeout=None): 2830 ''' 2831 List returns Managed Secrets for an Actor from a Secret Engine. 2832 ''' 2833 deadline = None if timeout is None else time.time() + timeout 2834 req = ManagedSecretListRequest() 2835 req.meta.CopyFrom(ListRequestMetadata()) 2836 if self.parent.page_limit > 0: 2837 req.meta.limit = self.parent.page_limit 2838 if self.parent.snapshot_datetime is not None: 2839 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2840 2841 req.filter = plumbing.quote_filter_args(filter, *args) 2842 2843 def generator(svc, req): 2844 tries = 0 2845 while True: 2846 t = None if deadline is None else deadline - time.time() 2847 try: 2848 plumbing_response = svc.stub.ListByActor( 2849 req, 2850 metadata=svc.parent.get_metadata( 2851 'ManagedSecrets.ListByActor', req), 2852 timeout=t) 2853 except Exception as e: 2854 if self.parent.shouldRetry(tries, e, deadline): 2855 tries += 1 2856 time.sleep( 2857 self.parent.exponentialBackoff(tries, deadline)) 2858 continue 2859 raise plumbing.convert_error_to_porcelain(e) from e 2860 tries = 0 2861 for plumbing_item in plumbing_response.managed_secrets: 2862 yield plumbing.convert_managed_secret_to_porcelain( 2863 plumbing_item) 2864 if plumbing_response.meta.next_cursor == '': 2865 break 2866 req.meta.cursor = plumbing_response.meta.next_cursor 2867 2868 return generator(self, req) 2869 2870 def create(self, managed_secret, timeout=None): 2871 ''' 2872 Create creates a Managed Secret 2873 ''' 2874 deadline = None if timeout is None else time.time() + timeout 2875 req = ManagedSecretCreateRequest() 2876 2877 if managed_secret is not None: 2878 req.managed_secret.CopyFrom( 2879 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2880 tries = 0 2881 plumbing_response = None 2882 while True: 2883 t = None if deadline is None else deadline - time.time() 2884 try: 2885 plumbing_response = self.stub.Create( 2886 req, 2887 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2888 req), 2889 timeout=t) 2890 except Exception as e: 2891 if self.parent.shouldRetry(tries, e, deadline): 2892 tries += 1 2893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2894 continue 2895 raise plumbing.convert_error_to_porcelain(e) from e 2896 break 2897 2898 resp = models.ManagedSecretCreateResponse() 2899 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2900 plumbing_response.managed_secret) 2901 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2902 plumbing_response.meta) 2903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2904 plumbing_response.rate_limit) 2905 return resp 2906 2907 def update(self, managed_secret, timeout=None): 2908 ''' 2909 Update updates a Managed Secret 2910 ''' 2911 deadline = None if timeout is None else time.time() + timeout 2912 req = ManagedSecretUpdateRequest() 2913 2914 if managed_secret is not None: 2915 req.managed_secret.CopyFrom( 2916 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2917 tries = 0 2918 plumbing_response = None 2919 while True: 2920 t = None if deadline is None else deadline - time.time() 2921 try: 2922 plumbing_response = self.stub.Update( 2923 req, 2924 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2925 req), 2926 timeout=t) 2927 except Exception as e: 2928 if self.parent.shouldRetry(tries, e, deadline): 2929 tries += 1 2930 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2931 continue 2932 raise plumbing.convert_error_to_porcelain(e) from e 2933 break 2934 2935 resp = models.ManagedSecretUpdateResponse() 2936 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2937 plumbing_response.managed_secret) 2938 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2939 plumbing_response.meta) 2940 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2941 plumbing_response.rate_limit) 2942 return resp 2943 2944 def rotate(self, id, timeout=None): 2945 ''' 2946 Rotate forces rotation of Managed Secret 2947 ''' 2948 deadline = None if timeout is None else time.time() + timeout 2949 req = ManagedSecretRotateRequest() 2950 2951 req.id = (id) 2952 tries = 0 2953 plumbing_response = None 2954 while True: 2955 t = None if deadline is None else deadline - time.time() 2956 try: 2957 plumbing_response = self.stub.Rotate( 2958 req, 2959 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2960 req), 2961 timeout=t) 2962 except Exception as e: 2963 if self.parent.shouldRetry(tries, e, deadline): 2964 tries += 1 2965 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2966 continue 2967 raise plumbing.convert_error_to_porcelain(e) from e 2968 break 2969 2970 resp = models.ManagedSecretRotateResponse() 2971 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2972 plumbing_response.meta) 2973 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2974 plumbing_response.rate_limit) 2975 return resp 2976 2977 def delete(self, id, timeout=None): 2978 ''' 2979 Delete deletes a Managed Secret 2980 ''' 2981 deadline = None if timeout is None else time.time() + timeout 2982 req = ManagedSecretDeleteRequest() 2983 2984 req.id = (id) 2985 tries = 0 2986 plumbing_response = None 2987 while True: 2988 t = None if deadline is None else deadline - time.time() 2989 try: 2990 plumbing_response = self.stub.Delete( 2991 req, 2992 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2993 req), 2994 timeout=t) 2995 except Exception as e: 2996 if self.parent.shouldRetry(tries, e, deadline): 2997 tries += 1 2998 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2999 continue 3000 raise plumbing.convert_error_to_porcelain(e) from e 3001 break 3002 3003 resp = models.ManagedSecretDeleteResponse() 3004 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3005 plumbing_response.rate_limit) 3006 return resp 3007 3008 def get(self, id, timeout=None): 3009 ''' 3010 Get gets details of a Managed Secret without sensitive data 3011 ''' 3012 deadline = None if timeout is None else time.time() + timeout 3013 req = ManagedSecretGetRequest() 3014 if self.parent.snapshot_datetime is not None: 3015 req.meta.CopyFrom(GetRequestMetadata()) 3016 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3017 3018 req.id = (id) 3019 tries = 0 3020 plumbing_response = None 3021 while True: 3022 t = None if deadline is None else deadline - time.time() 3023 try: 3024 plumbing_response = self.stub.Get( 3025 req, 3026 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3027 req), 3028 timeout=t) 3029 except Exception as e: 3030 if self.parent.shouldRetry(tries, e, deadline): 3031 tries += 1 3032 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3033 continue 3034 raise plumbing.convert_error_to_porcelain(e) from e 3035 break 3036 3037 resp = models.ManagedSecretGetResponse() 3038 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3039 plumbing_response.managed_secret) 3040 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3041 plumbing_response.meta) 3042 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3043 plumbing_response.rate_limit) 3044 return resp 3045 3046 def retrieve(self, id, public_key, timeout=None): 3047 ''' 3048 Retrieve returns Managed Secret with sensitive data 3049 ''' 3050 deadline = None if timeout is None else time.time() + timeout 3051 req = ManagedSecretRetrieveRequest() 3052 3053 req.id = (id) 3054 req.public_key = (public_key) 3055 tries = 0 3056 plumbing_response = None 3057 while True: 3058 t = None if deadline is None else deadline - time.time() 3059 try: 3060 plumbing_response = self.stub.Retrieve( 3061 req, 3062 metadata=self.parent.get_metadata( 3063 'ManagedSecrets.Retrieve', req), 3064 timeout=t) 3065 except Exception as e: 3066 if self.parent.shouldRetry(tries, e, deadline): 3067 tries += 1 3068 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3069 continue 3070 raise plumbing.convert_error_to_porcelain(e) from e 3071 break 3072 3073 resp = models.ManagedSecretRetrieveResponse() 3074 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3075 plumbing_response.managed_secret) 3076 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3077 plumbing_response.meta) 3078 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3079 plumbing_response.rate_limit) 3080 return resp 3081 3082 def validate(self, id, timeout=None): 3083 ''' 3084 Validate returns the result of testing the stored credential against the 3085 secret engine. 3086 ''' 3087 deadline = None if timeout is None else time.time() + timeout 3088 req = ManagedSecretValidateRequest() 3089 3090 req.id = (id) 3091 tries = 0 3092 plumbing_response = None 3093 while True: 3094 t = None if deadline is None else deadline - time.time() 3095 try: 3096 plumbing_response = self.stub.Validate( 3097 req, 3098 metadata=self.parent.get_metadata( 3099 'ManagedSecrets.Validate', req), 3100 timeout=t) 3101 except Exception as e: 3102 if self.parent.shouldRetry(tries, e, deadline): 3103 tries += 1 3104 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3105 continue 3106 raise plumbing.convert_error_to_porcelain(e) from e 3107 break 3108 3109 resp = models.ManagedSecretValidateResponse() 3110 resp.invalid_info = (plumbing_response.invalid_info) 3111 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3112 plumbing_response.meta) 3113 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3114 plumbing_response.rate_limit) 3115 resp.valid = (plumbing_response.valid) 3116 return resp 3117 3118 def logs(self, filter, *args, timeout=None): 3119 ''' 3120 Logs returns the audit records for the managed secret. This may be replaced 3121 in the future. 3122 ''' 3123 deadline = None if timeout is None else time.time() + timeout 3124 req = ManagedSecretLogsRequest() 3125 req.meta.CopyFrom(ListRequestMetadata()) 3126 if self.parent.page_limit > 0: 3127 req.meta.limit = self.parent.page_limit 3128 if self.parent.snapshot_datetime is not None: 3129 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3130 3131 req.filter = plumbing.quote_filter_args(filter, *args) 3132 3133 def generator(svc, req): 3134 tries = 0 3135 while True: 3136 t = None if deadline is None else deadline - time.time() 3137 try: 3138 plumbing_response = svc.stub.Logs( 3139 req, 3140 metadata=svc.parent.get_metadata( 3141 'ManagedSecrets.Logs', req), 3142 timeout=t) 3143 except Exception as e: 3144 if self.parent.shouldRetry(tries, e, deadline): 3145 tries += 1 3146 time.sleep( 3147 self.parent.exponentialBackoff(tries, deadline)) 3148 continue 3149 raise plumbing.convert_error_to_porcelain(e) from e 3150 tries = 0 3151 for plumbing_item in plumbing_response.managed_secret_logs: 3152 yield plumbing.convert_managed_secret_log_to_porcelain( 3153 plumbing_item) 3154 if plumbing_response.meta.next_cursor == '': 3155 break 3156 req.meta.cursor = plumbing_response.meta.next_cursor 3157 3158 return generator(self, req) 3159 3160 3161class Nodes: 3162 ''' 3163 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3164 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3165 - **Relays** are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections. 3166 See: 3167 `strongdm.models.Gateway` 3168 `strongdm.models.ProxyCluster` 3169 `strongdm.models.Relay` 3170 ''' 3171 def __init__(self, channel, client): 3172 self.parent = client 3173 self.stub = NodesStub(channel) 3174 3175 def create(self, node, timeout=None): 3176 ''' 3177 Create registers a new Node. 3178 ''' 3179 deadline = None if timeout is None else time.time() + timeout 3180 req = NodeCreateRequest() 3181 3182 if node is not None: 3183 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3184 tries = 0 3185 plumbing_response = None 3186 while True: 3187 t = None if deadline is None else deadline - time.time() 3188 try: 3189 plumbing_response = self.stub.Create( 3190 req, 3191 metadata=self.parent.get_metadata('Nodes.Create', req), 3192 timeout=t) 3193 except Exception as e: 3194 if self.parent.shouldRetry(tries, e, deadline): 3195 tries += 1 3196 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3197 continue 3198 raise plumbing.convert_error_to_porcelain(e) from e 3199 break 3200 3201 resp = models.NodeCreateResponse() 3202 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3203 plumbing_response.meta) 3204 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3205 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3206 plumbing_response.rate_limit) 3207 resp.token = (plumbing_response.token) 3208 return resp 3209 3210 def get(self, id, timeout=None): 3211 ''' 3212 Get reads one Node by ID. 3213 ''' 3214 deadline = None if timeout is None else time.time() + timeout 3215 req = NodeGetRequest() 3216 if self.parent.snapshot_datetime is not None: 3217 req.meta.CopyFrom(GetRequestMetadata()) 3218 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3219 3220 req.id = (id) 3221 tries = 0 3222 plumbing_response = None 3223 while True: 3224 t = None if deadline is None else deadline - time.time() 3225 try: 3226 plumbing_response = self.stub.Get( 3227 req, 3228 metadata=self.parent.get_metadata('Nodes.Get', req), 3229 timeout=t) 3230 except Exception as e: 3231 if self.parent.shouldRetry(tries, e, deadline): 3232 tries += 1 3233 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3234 continue 3235 raise plumbing.convert_error_to_porcelain(e) from e 3236 break 3237 3238 resp = models.NodeGetResponse() 3239 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3240 plumbing_response.meta) 3241 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3242 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3243 plumbing_response.rate_limit) 3244 return resp 3245 3246 def update(self, node, timeout=None): 3247 ''' 3248 Update replaces all the fields of a Node by ID. 3249 ''' 3250 deadline = None if timeout is None else time.time() + timeout 3251 req = NodeUpdateRequest() 3252 3253 if node is not None: 3254 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3255 tries = 0 3256 plumbing_response = None 3257 while True: 3258 t = None if deadline is None else deadline - time.time() 3259 try: 3260 plumbing_response = self.stub.Update( 3261 req, 3262 metadata=self.parent.get_metadata('Nodes.Update', req), 3263 timeout=t) 3264 except Exception as e: 3265 if self.parent.shouldRetry(tries, e, deadline): 3266 tries += 1 3267 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3268 continue 3269 raise plumbing.convert_error_to_porcelain(e) from e 3270 break 3271 3272 resp = models.NodeUpdateResponse() 3273 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3274 plumbing_response.meta) 3275 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3276 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3277 plumbing_response.rate_limit) 3278 return resp 3279 3280 def delete(self, id, timeout=None): 3281 ''' 3282 Delete removes a Node by ID. 3283 ''' 3284 deadline = None if timeout is None else time.time() + timeout 3285 req = NodeDeleteRequest() 3286 3287 req.id = (id) 3288 tries = 0 3289 plumbing_response = None 3290 while True: 3291 t = None if deadline is None else deadline - time.time() 3292 try: 3293 plumbing_response = self.stub.Delete( 3294 req, 3295 metadata=self.parent.get_metadata('Nodes.Delete', req), 3296 timeout=t) 3297 except Exception as e: 3298 if self.parent.shouldRetry(tries, e, deadline): 3299 tries += 1 3300 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3301 continue 3302 raise plumbing.convert_error_to_porcelain(e) from e 3303 break 3304 3305 resp = models.NodeDeleteResponse() 3306 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3307 plumbing_response.meta) 3308 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3309 plumbing_response.rate_limit) 3310 return resp 3311 3312 def list(self, filter, *args, timeout=None): 3313 ''' 3314 List gets a list of Nodes matching a given set of criteria. 3315 ''' 3316 deadline = None if timeout is None else time.time() + timeout 3317 req = NodeListRequest() 3318 req.meta.CopyFrom(ListRequestMetadata()) 3319 if self.parent.page_limit > 0: 3320 req.meta.limit = self.parent.page_limit 3321 if self.parent.snapshot_datetime is not None: 3322 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3323 3324 req.filter = plumbing.quote_filter_args(filter, *args) 3325 3326 def generator(svc, req): 3327 tries = 0 3328 while True: 3329 t = None if deadline is None else deadline - time.time() 3330 try: 3331 plumbing_response = svc.stub.List( 3332 req, 3333 metadata=svc.parent.get_metadata('Nodes.List', req), 3334 timeout=t) 3335 except Exception as e: 3336 if self.parent.shouldRetry(tries, e, deadline): 3337 tries += 1 3338 time.sleep( 3339 self.parent.exponentialBackoff(tries, deadline)) 3340 continue 3341 raise plumbing.convert_error_to_porcelain(e) from e 3342 tries = 0 3343 for plumbing_item in plumbing_response.nodes: 3344 yield plumbing.convert_node_to_porcelain(plumbing_item) 3345 if plumbing_response.meta.next_cursor == '': 3346 break 3347 req.meta.cursor = plumbing_response.meta.next_cursor 3348 3349 return generator(self, req) 3350 3351 3352class SnapshotNodes: 3353 ''' 3354 SnapshotNodes exposes the read only methods of the Nodes 3355 service for historical queries. 3356 ''' 3357 def __init__(self, nodes): 3358 self.nodes = nodes 3359 3360 def get(self, id, timeout=None): 3361 ''' 3362 Get reads one Node by ID. 3363 ''' 3364 return self.nodes.get(id, timeout=timeout) 3365 3366 def list(self, filter, *args, timeout=None): 3367 ''' 3368 List gets a list of Nodes matching a given set of criteria. 3369 ''' 3370 return self.nodes.list(filter, *args, timeout=timeout) 3371 3372 3373class NodesHistory: 3374 ''' 3375 NodesHistory records all changes to the state of a Node. 3376 See `strongdm.models.NodeHistory`. 3377 ''' 3378 def __init__(self, channel, client): 3379 self.parent = client 3380 self.stub = NodesHistoryStub(channel) 3381 3382 def list(self, filter, *args, timeout=None): 3383 ''' 3384 List gets a list of NodeHistory records matching a given set of criteria. 3385 ''' 3386 deadline = None if timeout is None else time.time() + timeout 3387 req = NodeHistoryListRequest() 3388 req.meta.CopyFrom(ListRequestMetadata()) 3389 if self.parent.page_limit > 0: 3390 req.meta.limit = self.parent.page_limit 3391 if self.parent.snapshot_datetime is not None: 3392 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3393 3394 req.filter = plumbing.quote_filter_args(filter, *args) 3395 3396 def generator(svc, req): 3397 tries = 0 3398 while True: 3399 t = None if deadline is None else deadline - time.time() 3400 try: 3401 plumbing_response = svc.stub.List( 3402 req, 3403 metadata=svc.parent.get_metadata( 3404 'NodesHistory.List', req), 3405 timeout=t) 3406 except Exception as e: 3407 if self.parent.shouldRetry(tries, e, deadline): 3408 tries += 1 3409 time.sleep( 3410 self.parent.exponentialBackoff(tries, deadline)) 3411 continue 3412 raise plumbing.convert_error_to_porcelain(e) from e 3413 tries = 0 3414 for plumbing_item in plumbing_response.history: 3415 yield plumbing.convert_node_history_to_porcelain( 3416 plumbing_item) 3417 if plumbing_response.meta.next_cursor == '': 3418 break 3419 req.meta.cursor = plumbing_response.meta.next_cursor 3420 3421 return generator(self, req) 3422 3423 3424class OrganizationHistory: 3425 ''' 3426 OrganizationHistory records all changes to the state of an Organization. 3427 See `strongdm.models.OrganizationHistoryRecord`. 3428 ''' 3429 def __init__(self, channel, client): 3430 self.parent = client 3431 self.stub = OrganizationHistoryStub(channel) 3432 3433 def list(self, filter, *args, timeout=None): 3434 ''' 3435 List gets a list of OrganizationHistory records matching a given set of criteria. 3436 ''' 3437 deadline = None if timeout is None else time.time() + timeout 3438 req = OrganizationHistoryListRequest() 3439 req.meta.CopyFrom(ListRequestMetadata()) 3440 if self.parent.page_limit > 0: 3441 req.meta.limit = self.parent.page_limit 3442 if self.parent.snapshot_datetime is not None: 3443 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3444 3445 req.filter = plumbing.quote_filter_args(filter, *args) 3446 3447 def generator(svc, req): 3448 tries = 0 3449 while True: 3450 t = None if deadline is None else deadline - time.time() 3451 try: 3452 plumbing_response = svc.stub.List( 3453 req, 3454 metadata=svc.parent.get_metadata( 3455 'OrganizationHistory.List', req), 3456 timeout=t) 3457 except Exception as e: 3458 if self.parent.shouldRetry(tries, e, deadline): 3459 tries += 1 3460 time.sleep( 3461 self.parent.exponentialBackoff(tries, deadline)) 3462 continue 3463 raise plumbing.convert_error_to_porcelain(e) from e 3464 tries = 0 3465 for plumbing_item in plumbing_response.history: 3466 yield plumbing.convert_organization_history_record_to_porcelain( 3467 plumbing_item) 3468 if plumbing_response.meta.next_cursor == '': 3469 break 3470 req.meta.cursor = plumbing_response.meta.next_cursor 3471 3472 return generator(self, req) 3473 3474 3475class PeeringGroupNodes: 3476 ''' 3477 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3478 See `strongdm.models.PeeringGroupNode`. 3479 ''' 3480 def __init__(self, channel, client): 3481 self.parent = client 3482 self.stub = PeeringGroupNodesStub(channel) 3483 3484 def create(self, peering_group_node, timeout=None): 3485 ''' 3486 Create attaches a Node to a PeeringGroup 3487 ''' 3488 deadline = None if timeout is None else time.time() + timeout 3489 req = PeeringGroupNodeCreateRequest() 3490 3491 if peering_group_node is not None: 3492 req.peering_group_node.CopyFrom( 3493 plumbing.convert_peering_group_node_to_plumbing( 3494 peering_group_node)) 3495 tries = 0 3496 plumbing_response = None 3497 while True: 3498 t = None if deadline is None else deadline - time.time() 3499 try: 3500 plumbing_response = self.stub.Create( 3501 req, 3502 metadata=self.parent.get_metadata( 3503 'PeeringGroupNodes.Create', req), 3504 timeout=t) 3505 except Exception as e: 3506 if self.parent.shouldRetry(tries, e, deadline): 3507 tries += 1 3508 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3509 continue 3510 raise plumbing.convert_error_to_porcelain(e) from e 3511 break 3512 3513 resp = models.PeeringGroupNodeCreateResponse() 3514 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3515 plumbing_response.meta) 3516 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3517 plumbing_response.peering_group_node) 3518 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3519 plumbing_response.rate_limit) 3520 return resp 3521 3522 def delete(self, id, timeout=None): 3523 ''' 3524 Delete detaches a Node to a PeeringGroup. 3525 ''' 3526 deadline = None if timeout is None else time.time() + timeout 3527 req = PeeringGroupNodeDeleteRequest() 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.Delete( 3536 req, 3537 metadata=self.parent.get_metadata( 3538 'PeeringGroupNodes.Delete', req), 3539 timeout=t) 3540 except Exception as e: 3541 if self.parent.shouldRetry(tries, e, deadline): 3542 tries += 1 3543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3544 continue 3545 raise plumbing.convert_error_to_porcelain(e) from e 3546 break 3547 3548 resp = models.PeeringGroupNodeDeleteResponse() 3549 resp.meta = plumbing.convert_delete_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 get(self, id, timeout=None): 3556 ''' 3557 Get reads the information of one peering group to node attachment. 3558 ''' 3559 deadline = None if timeout is None else time.time() + timeout 3560 req = PeeringGroupNodeGetRequest() 3561 if self.parent.snapshot_datetime is not None: 3562 req.meta.CopyFrom(GetRequestMetadata()) 3563 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3564 3565 req.id = (id) 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.Get( 3572 req, 3573 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 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.PeeringGroupNodeGetResponse() 3585 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3586 plumbing_response.meta) 3587 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3588 plumbing_response.peering_group_node) 3589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3590 plumbing_response.rate_limit) 3591 return resp 3592 3593 def list(self, filter, *args, timeout=None): 3594 ''' 3595 List gets a list of peering group node attachments. 3596 ''' 3597 deadline = None if timeout is None else time.time() + timeout 3598 req = PeeringGroupNodeListRequest() 3599 req.meta.CopyFrom(ListRequestMetadata()) 3600 if self.parent.page_limit > 0: 3601 req.meta.limit = self.parent.page_limit 3602 if self.parent.snapshot_datetime is not None: 3603 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3604 3605 req.filter = plumbing.quote_filter_args(filter, *args) 3606 3607 def generator(svc, req): 3608 tries = 0 3609 while True: 3610 t = None if deadline is None else deadline - time.time() 3611 try: 3612 plumbing_response = svc.stub.List( 3613 req, 3614 metadata=svc.parent.get_metadata( 3615 'PeeringGroupNodes.List', req), 3616 timeout=t) 3617 except Exception as e: 3618 if self.parent.shouldRetry(tries, e, deadline): 3619 tries += 1 3620 time.sleep( 3621 self.parent.exponentialBackoff(tries, deadline)) 3622 continue 3623 raise plumbing.convert_error_to_porcelain(e) from e 3624 tries = 0 3625 for plumbing_item in plumbing_response.peering_group_nodes: 3626 yield plumbing.convert_peering_group_node_to_porcelain( 3627 plumbing_item) 3628 if plumbing_response.meta.next_cursor == '': 3629 break 3630 req.meta.cursor = plumbing_response.meta.next_cursor 3631 3632 return generator(self, req) 3633 3634 3635class PeeringGroupPeers: 3636 ''' 3637 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3638 See `strongdm.models.PeeringGroupPeer`. 3639 ''' 3640 def __init__(self, channel, client): 3641 self.parent = client 3642 self.stub = PeeringGroupPeersStub(channel) 3643 3644 def create(self, peering_group_peer, timeout=None): 3645 ''' 3646 Create links two peering groups. 3647 ''' 3648 deadline = None if timeout is None else time.time() + timeout 3649 req = PeeringGroupPeerCreateRequest() 3650 3651 if peering_group_peer is not None: 3652 req.peering_group_peer.CopyFrom( 3653 plumbing.convert_peering_group_peer_to_plumbing( 3654 peering_group_peer)) 3655 tries = 0 3656 plumbing_response = None 3657 while True: 3658 t = None if deadline is None else deadline - time.time() 3659 try: 3660 plumbing_response = self.stub.Create( 3661 req, 3662 metadata=self.parent.get_metadata( 3663 'PeeringGroupPeers.Create', req), 3664 timeout=t) 3665 except Exception as e: 3666 if self.parent.shouldRetry(tries, e, deadline): 3667 tries += 1 3668 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3669 continue 3670 raise plumbing.convert_error_to_porcelain(e) from e 3671 break 3672 3673 resp = models.PeeringGroupPeerCreateResponse() 3674 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3675 plumbing_response.meta) 3676 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3677 plumbing_response.peering_group_peer) 3678 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3679 plumbing_response.rate_limit) 3680 return resp 3681 3682 def delete(self, id, timeout=None): 3683 ''' 3684 Delete unlinks two peering groups. 3685 ''' 3686 deadline = None if timeout is None else time.time() + timeout 3687 req = PeeringGroupPeerDeleteRequest() 3688 3689 req.id = (id) 3690 tries = 0 3691 plumbing_response = None 3692 while True: 3693 t = None if deadline is None else deadline - time.time() 3694 try: 3695 plumbing_response = self.stub.Delete( 3696 req, 3697 metadata=self.parent.get_metadata( 3698 'PeeringGroupPeers.Delete', req), 3699 timeout=t) 3700 except Exception as e: 3701 if self.parent.shouldRetry(tries, e, deadline): 3702 tries += 1 3703 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3704 continue 3705 raise plumbing.convert_error_to_porcelain(e) from e 3706 break 3707 3708 resp = models.PeeringGroupPeerDeleteResponse() 3709 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3710 plumbing_response.meta) 3711 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3712 plumbing_response.rate_limit) 3713 return resp 3714 3715 def get(self, id, timeout=None): 3716 ''' 3717 Get reads the information of one peering group link. 3718 ''' 3719 deadline = None if timeout is None else time.time() + timeout 3720 req = PeeringGroupPeerGetRequest() 3721 if self.parent.snapshot_datetime is not None: 3722 req.meta.CopyFrom(GetRequestMetadata()) 3723 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3724 3725 req.id = (id) 3726 tries = 0 3727 plumbing_response = None 3728 while True: 3729 t = None if deadline is None else deadline - time.time() 3730 try: 3731 plumbing_response = self.stub.Get( 3732 req, 3733 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3734 req), 3735 timeout=t) 3736 except Exception as e: 3737 if self.parent.shouldRetry(tries, e, deadline): 3738 tries += 1 3739 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3740 continue 3741 raise plumbing.convert_error_to_porcelain(e) from e 3742 break 3743 3744 resp = models.PeeringGroupPeerGetResponse() 3745 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3746 plumbing_response.meta) 3747 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3748 plumbing_response.peering_group_peer) 3749 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3750 plumbing_response.rate_limit) 3751 return resp 3752 3753 def list(self, filter, *args, timeout=None): 3754 ''' 3755 List gets a list of peering group links. 3756 ''' 3757 deadline = None if timeout is None else time.time() + timeout 3758 req = PeeringGroupPeerListRequest() 3759 req.meta.CopyFrom(ListRequestMetadata()) 3760 if self.parent.page_limit > 0: 3761 req.meta.limit = self.parent.page_limit 3762 if self.parent.snapshot_datetime is not None: 3763 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3764 3765 req.filter = plumbing.quote_filter_args(filter, *args) 3766 3767 def generator(svc, req): 3768 tries = 0 3769 while True: 3770 t = None if deadline is None else deadline - time.time() 3771 try: 3772 plumbing_response = svc.stub.List( 3773 req, 3774 metadata=svc.parent.get_metadata( 3775 'PeeringGroupPeers.List', req), 3776 timeout=t) 3777 except Exception as e: 3778 if self.parent.shouldRetry(tries, e, deadline): 3779 tries += 1 3780 time.sleep( 3781 self.parent.exponentialBackoff(tries, deadline)) 3782 continue 3783 raise plumbing.convert_error_to_porcelain(e) from e 3784 tries = 0 3785 for plumbing_item in plumbing_response.peering_group_peers: 3786 yield plumbing.convert_peering_group_peer_to_porcelain( 3787 plumbing_item) 3788 if plumbing_response.meta.next_cursor == '': 3789 break 3790 req.meta.cursor = plumbing_response.meta.next_cursor 3791 3792 return generator(self, req) 3793 3794 3795class PeeringGroupResources: 3796 ''' 3797 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 3798 See `strongdm.models.PeeringGroupResource`. 3799 ''' 3800 def __init__(self, channel, client): 3801 self.parent = client 3802 self.stub = PeeringGroupResourcesStub(channel) 3803 3804 def create(self, peering_group_resource, timeout=None): 3805 ''' 3806 Create attaches a Resource to a PeeringGroup 3807 ''' 3808 deadline = None if timeout is None else time.time() + timeout 3809 req = PeeringGroupResourceCreateRequest() 3810 3811 if peering_group_resource is not None: 3812 req.peering_group_resource.CopyFrom( 3813 plumbing.convert_peering_group_resource_to_plumbing( 3814 peering_group_resource)) 3815 tries = 0 3816 plumbing_response = None 3817 while True: 3818 t = None if deadline is None else deadline - time.time() 3819 try: 3820 plumbing_response = self.stub.Create( 3821 req, 3822 metadata=self.parent.get_metadata( 3823 'PeeringGroupResources.Create', req), 3824 timeout=t) 3825 except Exception as e: 3826 if self.parent.shouldRetry(tries, e, deadline): 3827 tries += 1 3828 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3829 continue 3830 raise plumbing.convert_error_to_porcelain(e) from e 3831 break 3832 3833 resp = models.PeeringGroupResourceCreateResponse() 3834 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3835 plumbing_response.meta) 3836 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3837 plumbing_response.peering_group_resource) 3838 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3839 plumbing_response.rate_limit) 3840 return resp 3841 3842 def delete(self, id, timeout=None): 3843 ''' 3844 Delete detaches a Resource to a PeeringGroup 3845 ''' 3846 deadline = None if timeout is None else time.time() + timeout 3847 req = PeeringGroupResourceDeleteRequest() 3848 3849 req.id = (id) 3850 tries = 0 3851 plumbing_response = None 3852 while True: 3853 t = None if deadline is None else deadline - time.time() 3854 try: 3855 plumbing_response = self.stub.Delete( 3856 req, 3857 metadata=self.parent.get_metadata( 3858 'PeeringGroupResources.Delete', req), 3859 timeout=t) 3860 except Exception as e: 3861 if self.parent.shouldRetry(tries, e, deadline): 3862 tries += 1 3863 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3864 continue 3865 raise plumbing.convert_error_to_porcelain(e) from e 3866 break 3867 3868 resp = models.PeeringGroupResourceDeleteResponse() 3869 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3870 plumbing_response.meta) 3871 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3872 plumbing_response.rate_limit) 3873 return resp 3874 3875 def get(self, id, timeout=None): 3876 ''' 3877 Get reads the information of one peering group to resource attachment. 3878 ''' 3879 deadline = None if timeout is None else time.time() + timeout 3880 req = PeeringGroupResourceGetRequest() 3881 if self.parent.snapshot_datetime is not None: 3882 req.meta.CopyFrom(GetRequestMetadata()) 3883 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3884 3885 req.id = (id) 3886 tries = 0 3887 plumbing_response = None 3888 while True: 3889 t = None if deadline is None else deadline - time.time() 3890 try: 3891 plumbing_response = self.stub.Get( 3892 req, 3893 metadata=self.parent.get_metadata( 3894 'PeeringGroupResources.Get', req), 3895 timeout=t) 3896 except Exception as e: 3897 if self.parent.shouldRetry(tries, e, deadline): 3898 tries += 1 3899 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3900 continue 3901 raise plumbing.convert_error_to_porcelain(e) from e 3902 break 3903 3904 resp = models.PeeringGroupResourceGetResponse() 3905 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3906 plumbing_response.meta) 3907 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3908 plumbing_response.peering_group_resource) 3909 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3910 plumbing_response.rate_limit) 3911 return resp 3912 3913 def list(self, filter, *args, timeout=None): 3914 ''' 3915 List gets a list of peering group resource attachments. 3916 ''' 3917 deadline = None if timeout is None else time.time() + timeout 3918 req = PeeringGroupResourceListRequest() 3919 req.meta.CopyFrom(ListRequestMetadata()) 3920 if self.parent.page_limit > 0: 3921 req.meta.limit = self.parent.page_limit 3922 if self.parent.snapshot_datetime is not None: 3923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3924 3925 req.filter = plumbing.quote_filter_args(filter, *args) 3926 3927 def generator(svc, req): 3928 tries = 0 3929 while True: 3930 t = None if deadline is None else deadline - time.time() 3931 try: 3932 plumbing_response = svc.stub.List( 3933 req, 3934 metadata=svc.parent.get_metadata( 3935 'PeeringGroupResources.List', req), 3936 timeout=t) 3937 except Exception as e: 3938 if self.parent.shouldRetry(tries, e, deadline): 3939 tries += 1 3940 time.sleep( 3941 self.parent.exponentialBackoff(tries, deadline)) 3942 continue 3943 raise plumbing.convert_error_to_porcelain(e) from e 3944 tries = 0 3945 for plumbing_item in plumbing_response.peering_group_resources: 3946 yield plumbing.convert_peering_group_resource_to_porcelain( 3947 plumbing_item) 3948 if plumbing_response.meta.next_cursor == '': 3949 break 3950 req.meta.cursor = plumbing_response.meta.next_cursor 3951 3952 return generator(self, req) 3953 3954 3955class PeeringGroups: 3956 ''' 3957 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 3958 See `strongdm.models.PeeringGroup`. 3959 ''' 3960 def __init__(self, channel, client): 3961 self.parent = client 3962 self.stub = PeeringGroupsStub(channel) 3963 3964 def create(self, peering_group, timeout=None): 3965 ''' 3966 Create registers a new PeeringGroup. 3967 ''' 3968 deadline = None if timeout is None else time.time() + timeout 3969 req = PeeringGroupCreateRequest() 3970 3971 if peering_group is not None: 3972 req.peering_group.CopyFrom( 3973 plumbing.convert_peering_group_to_plumbing(peering_group)) 3974 tries = 0 3975 plumbing_response = None 3976 while True: 3977 t = None if deadline is None else deadline - time.time() 3978 try: 3979 plumbing_response = self.stub.Create( 3980 req, 3981 metadata=self.parent.get_metadata('PeeringGroups.Create', 3982 req), 3983 timeout=t) 3984 except Exception as e: 3985 if self.parent.shouldRetry(tries, e, deadline): 3986 tries += 1 3987 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3988 continue 3989 raise plumbing.convert_error_to_porcelain(e) from e 3990 break 3991 3992 resp = models.PeeringGroupCreateResponse() 3993 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3994 plumbing_response.meta) 3995 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3996 plumbing_response.peering_group) 3997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3998 plumbing_response.rate_limit) 3999 return resp 4000 4001 def delete(self, id, timeout=None): 4002 ''' 4003 Delete removes a PeeringGroup by ID. 4004 ''' 4005 deadline = None if timeout is None else time.time() + timeout 4006 req = PeeringGroupDeleteRequest() 4007 4008 req.id = (id) 4009 tries = 0 4010 plumbing_response = None 4011 while True: 4012 t = None if deadline is None else deadline - time.time() 4013 try: 4014 plumbing_response = self.stub.Delete( 4015 req, 4016 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4017 req), 4018 timeout=t) 4019 except Exception as e: 4020 if self.parent.shouldRetry(tries, e, deadline): 4021 tries += 1 4022 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4023 continue 4024 raise plumbing.convert_error_to_porcelain(e) from e 4025 break 4026 4027 resp = models.PeeringGroupDeleteResponse() 4028 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4029 plumbing_response.meta) 4030 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4031 plumbing_response.rate_limit) 4032 return resp 4033 4034 def get(self, id, timeout=None): 4035 ''' 4036 Get reads one PeeringGroup by ID. It will load all its dependencies. 4037 ''' 4038 deadline = None if timeout is None else time.time() + timeout 4039 req = PeeringGroupGetRequest() 4040 if self.parent.snapshot_datetime is not None: 4041 req.meta.CopyFrom(GetRequestMetadata()) 4042 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4043 4044 req.id = (id) 4045 tries = 0 4046 plumbing_response = None 4047 while True: 4048 t = None if deadline is None else deadline - time.time() 4049 try: 4050 plumbing_response = self.stub.Get( 4051 req, 4052 metadata=self.parent.get_metadata('PeeringGroups.Get', 4053 req), 4054 timeout=t) 4055 except Exception as e: 4056 if self.parent.shouldRetry(tries, e, deadline): 4057 tries += 1 4058 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4059 continue 4060 raise plumbing.convert_error_to_porcelain(e) from e 4061 break 4062 4063 resp = models.PeeringGroupGetResponse() 4064 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4065 plumbing_response.meta) 4066 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4067 plumbing_response.peering_group) 4068 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4069 plumbing_response.rate_limit) 4070 return resp 4071 4072 def list(self, filter, *args, timeout=None): 4073 ''' 4074 List gets a list of Peering Groups. 4075 ''' 4076 deadline = None if timeout is None else time.time() + timeout 4077 req = PeeringGroupListRequest() 4078 req.meta.CopyFrom(ListRequestMetadata()) 4079 if self.parent.page_limit > 0: 4080 req.meta.limit = self.parent.page_limit 4081 if self.parent.snapshot_datetime is not None: 4082 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4083 4084 req.filter = plumbing.quote_filter_args(filter, *args) 4085 4086 def generator(svc, req): 4087 tries = 0 4088 while True: 4089 t = None if deadline is None else deadline - time.time() 4090 try: 4091 plumbing_response = svc.stub.List( 4092 req, 4093 metadata=svc.parent.get_metadata( 4094 'PeeringGroups.List', req), 4095 timeout=t) 4096 except Exception as e: 4097 if self.parent.shouldRetry(tries, e, deadline): 4098 tries += 1 4099 time.sleep( 4100 self.parent.exponentialBackoff(tries, deadline)) 4101 continue 4102 raise plumbing.convert_error_to_porcelain(e) from e 4103 tries = 0 4104 for plumbing_item in plumbing_response.peering_groups: 4105 yield plumbing.convert_peering_group_to_porcelain( 4106 plumbing_item) 4107 if plumbing_response.meta.next_cursor == '': 4108 break 4109 req.meta.cursor = plumbing_response.meta.next_cursor 4110 4111 return generator(self, req) 4112 4113 4114class Policies: 4115 ''' 4116 Policies are the collection of one or more statements that enforce fine-grained access 4117 control for the users of an organization. 4118 See `strongdm.models.Policy`. 4119 ''' 4120 def __init__(self, channel, client): 4121 self.parent = client 4122 self.stub = PoliciesStub(channel) 4123 4124 def create(self, policy, timeout=None): 4125 ''' 4126 Create creates a new Policy. 4127 ''' 4128 deadline = None if timeout is None else time.time() + timeout 4129 req = PolicyCreateRequest() 4130 4131 if policy is not None: 4132 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4133 tries = 0 4134 plumbing_response = None 4135 while True: 4136 t = None if deadline is None else deadline - time.time() 4137 try: 4138 plumbing_response = self.stub.Create( 4139 req, 4140 metadata=self.parent.get_metadata('Policies.Create', req), 4141 timeout=t) 4142 except Exception as e: 4143 if self.parent.shouldRetry(tries, e, deadline): 4144 tries += 1 4145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4146 continue 4147 raise plumbing.convert_error_to_porcelain(e) from e 4148 break 4149 4150 resp = models.PolicyCreateResponse() 4151 resp.policy = plumbing.convert_policy_to_porcelain( 4152 plumbing_response.policy) 4153 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4154 plumbing_response.rate_limit) 4155 return resp 4156 4157 def delete(self, id, timeout=None): 4158 ''' 4159 Delete removes a Policy by ID. 4160 ''' 4161 deadline = None if timeout is None else time.time() + timeout 4162 req = PolicyDeleteRequest() 4163 4164 req.id = (id) 4165 tries = 0 4166 plumbing_response = None 4167 while True: 4168 t = None if deadline is None else deadline - time.time() 4169 try: 4170 plumbing_response = self.stub.Delete( 4171 req, 4172 metadata=self.parent.get_metadata('Policies.Delete', req), 4173 timeout=t) 4174 except Exception as e: 4175 if self.parent.shouldRetry(tries, e, deadline): 4176 tries += 1 4177 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4178 continue 4179 raise plumbing.convert_error_to_porcelain(e) from e 4180 break 4181 4182 resp = models.PolicyDeleteResponse() 4183 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4184 plumbing_response.rate_limit) 4185 return resp 4186 4187 def update(self, policy, timeout=None): 4188 ''' 4189 Update replaces all the fields of a Policy by ID. 4190 ''' 4191 deadline = None if timeout is None else time.time() + timeout 4192 req = PolicyUpdateRequest() 4193 4194 if policy is not None: 4195 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4196 tries = 0 4197 plumbing_response = None 4198 while True: 4199 t = None if deadline is None else deadline - time.time() 4200 try: 4201 plumbing_response = self.stub.Update( 4202 req, 4203 metadata=self.parent.get_metadata('Policies.Update', req), 4204 timeout=t) 4205 except Exception as e: 4206 if self.parent.shouldRetry(tries, e, deadline): 4207 tries += 1 4208 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4209 continue 4210 raise plumbing.convert_error_to_porcelain(e) from e 4211 break 4212 4213 resp = models.PolicyUpdateResponse() 4214 resp.policy = plumbing.convert_policy_to_porcelain( 4215 plumbing_response.policy) 4216 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4217 plumbing_response.rate_limit) 4218 return resp 4219 4220 def get(self, id, timeout=None): 4221 ''' 4222 Get reads one Policy by ID. 4223 ''' 4224 deadline = None if timeout is None else time.time() + timeout 4225 req = PolicyGetRequest() 4226 if self.parent.snapshot_datetime is not None: 4227 req.meta.CopyFrom(GetRequestMetadata()) 4228 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4229 4230 req.id = (id) 4231 tries = 0 4232 plumbing_response = None 4233 while True: 4234 t = None if deadline is None else deadline - time.time() 4235 try: 4236 plumbing_response = self.stub.Get( 4237 req, 4238 metadata=self.parent.get_metadata('Policies.Get', req), 4239 timeout=t) 4240 except Exception as e: 4241 if self.parent.shouldRetry(tries, e, deadline): 4242 tries += 1 4243 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4244 continue 4245 raise plumbing.convert_error_to_porcelain(e) from e 4246 break 4247 4248 resp = models.PolicyGetResponse() 4249 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4250 plumbing_response.meta) 4251 resp.policy = plumbing.convert_policy_to_porcelain( 4252 plumbing_response.policy) 4253 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4254 plumbing_response.rate_limit) 4255 return resp 4256 4257 def list(self, filter, *args, timeout=None): 4258 ''' 4259 List gets a list of Policy matching a given set of criteria 4260 ''' 4261 deadline = None if timeout is None else time.time() + timeout 4262 req = PolicyListRequest() 4263 req.meta.CopyFrom(ListRequestMetadata()) 4264 if self.parent.page_limit > 0: 4265 req.meta.limit = self.parent.page_limit 4266 if self.parent.snapshot_datetime is not None: 4267 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4268 4269 req.filter = plumbing.quote_filter_args(filter, *args) 4270 4271 def generator(svc, req): 4272 tries = 0 4273 while True: 4274 t = None if deadline is None else deadline - time.time() 4275 try: 4276 plumbing_response = svc.stub.List( 4277 req, 4278 metadata=svc.parent.get_metadata('Policies.List', req), 4279 timeout=t) 4280 except Exception as e: 4281 if self.parent.shouldRetry(tries, e, deadline): 4282 tries += 1 4283 time.sleep( 4284 self.parent.exponentialBackoff(tries, deadline)) 4285 continue 4286 raise plumbing.convert_error_to_porcelain(e) from e 4287 tries = 0 4288 for plumbing_item in plumbing_response.policies: 4289 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4290 if plumbing_response.meta.next_cursor == '': 4291 break 4292 req.meta.cursor = plumbing_response.meta.next_cursor 4293 4294 return generator(self, req) 4295 4296 4297class SnapshotPolicies: 4298 ''' 4299 SnapshotPolicies exposes the read only methods of the Policies 4300 service for historical queries. 4301 ''' 4302 def __init__(self, policies): 4303 self.policies = policies 4304 4305 def get(self, id, timeout=None): 4306 ''' 4307 Get reads one Policy by ID. 4308 ''' 4309 return self.policies.get(id, timeout=timeout) 4310 4311 def list(self, filter, *args, timeout=None): 4312 ''' 4313 List gets a list of Policy matching a given set of criteria 4314 ''' 4315 return self.policies.list(filter, *args, timeout=timeout) 4316 4317 4318class PoliciesHistory: 4319 ''' 4320 PoliciesHistory records all changes to the state of a Policy. 4321 See `strongdm.models.PolicyHistory`. 4322 ''' 4323 def __init__(self, channel, client): 4324 self.parent = client 4325 self.stub = PoliciesHistoryStub(channel) 4326 4327 def list(self, filter, *args, timeout=None): 4328 ''' 4329 List gets a list of PolicyHistory records matching a given set of criteria. 4330 ''' 4331 deadline = None if timeout is None else time.time() + timeout 4332 req = PoliciesHistoryListRequest() 4333 req.meta.CopyFrom(ListRequestMetadata()) 4334 if self.parent.page_limit > 0: 4335 req.meta.limit = self.parent.page_limit 4336 if self.parent.snapshot_datetime is not None: 4337 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4338 4339 req.filter = plumbing.quote_filter_args(filter, *args) 4340 4341 def generator(svc, req): 4342 tries = 0 4343 while True: 4344 t = None if deadline is None else deadline - time.time() 4345 try: 4346 plumbing_response = svc.stub.List( 4347 req, 4348 metadata=svc.parent.get_metadata( 4349 'PoliciesHistory.List', req), 4350 timeout=t) 4351 except Exception as e: 4352 if self.parent.shouldRetry(tries, e, deadline): 4353 tries += 1 4354 time.sleep( 4355 self.parent.exponentialBackoff(tries, deadline)) 4356 continue 4357 raise plumbing.convert_error_to_porcelain(e) from e 4358 tries = 0 4359 for plumbing_item in plumbing_response.history: 4360 yield plumbing.convert_policy_history_to_porcelain( 4361 plumbing_item) 4362 if plumbing_response.meta.next_cursor == '': 4363 break 4364 req.meta.cursor = plumbing_response.meta.next_cursor 4365 4366 return generator(self, req) 4367 4368 4369class ProxyClusterKeys: 4370 ''' 4371 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4372 The proxies within a cluster share the same key. One cluster can have 4373 multiple keys in order to facilitate key rotation. 4374 See `strongdm.models.ProxyClusterKey`. 4375 ''' 4376 def __init__(self, channel, client): 4377 self.parent = client 4378 self.stub = ProxyClusterKeysStub(channel) 4379 4380 def create(self, proxy_cluster_key, timeout=None): 4381 ''' 4382 Create registers a new ProxyClusterKey. 4383 ''' 4384 deadline = None if timeout is None else time.time() + timeout 4385 req = ProxyClusterKeyCreateRequest() 4386 4387 if proxy_cluster_key is not None: 4388 req.proxy_cluster_key.CopyFrom( 4389 plumbing.convert_proxy_cluster_key_to_plumbing( 4390 proxy_cluster_key)) 4391 tries = 0 4392 plumbing_response = None 4393 while True: 4394 t = None if deadline is None else deadline - time.time() 4395 try: 4396 plumbing_response = self.stub.Create( 4397 req, 4398 metadata=self.parent.get_metadata( 4399 'ProxyClusterKeys.Create', req), 4400 timeout=t) 4401 except Exception as e: 4402 if self.parent.shouldRetry(tries, e, deadline): 4403 tries += 1 4404 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4405 continue 4406 raise plumbing.convert_error_to_porcelain(e) from e 4407 break 4408 4409 resp = models.ProxyClusterKeyCreateResponse() 4410 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4411 plumbing_response.meta) 4412 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4413 plumbing_response.proxy_cluster_key) 4414 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4415 plumbing_response.rate_limit) 4416 resp.secret_key = (plumbing_response.secret_key) 4417 return resp 4418 4419 def get(self, id, timeout=None): 4420 ''' 4421 Get reads one ProxyClusterKey by ID. 4422 ''' 4423 deadline = None if timeout is None else time.time() + timeout 4424 req = ProxyClusterKeyGetRequest() 4425 if self.parent.snapshot_datetime is not None: 4426 req.meta.CopyFrom(GetRequestMetadata()) 4427 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4428 4429 req.id = (id) 4430 tries = 0 4431 plumbing_response = None 4432 while True: 4433 t = None if deadline is None else deadline - time.time() 4434 try: 4435 plumbing_response = self.stub.Get( 4436 req, 4437 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4438 req), 4439 timeout=t) 4440 except Exception as e: 4441 if self.parent.shouldRetry(tries, e, deadline): 4442 tries += 1 4443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4444 continue 4445 raise plumbing.convert_error_to_porcelain(e) from e 4446 break 4447 4448 resp = models.ProxyClusterKeyGetResponse() 4449 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4450 plumbing_response.meta) 4451 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4452 plumbing_response.proxy_cluster_key) 4453 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4454 plumbing_response.rate_limit) 4455 return resp 4456 4457 def delete(self, id, timeout=None): 4458 ''' 4459 Delete removes a ProxyClusterKey by ID. 4460 ''' 4461 deadline = None if timeout is None else time.time() + timeout 4462 req = ProxyClusterKeyDeleteRequest() 4463 4464 req.id = (id) 4465 tries = 0 4466 plumbing_response = None 4467 while True: 4468 t = None if deadline is None else deadline - time.time() 4469 try: 4470 plumbing_response = self.stub.Delete( 4471 req, 4472 metadata=self.parent.get_metadata( 4473 'ProxyClusterKeys.Delete', req), 4474 timeout=t) 4475 except Exception as e: 4476 if self.parent.shouldRetry(tries, e, deadline): 4477 tries += 1 4478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4479 continue 4480 raise plumbing.convert_error_to_porcelain(e) from e 4481 break 4482 4483 resp = models.ProxyClusterKeyDeleteResponse() 4484 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4485 plumbing_response.meta) 4486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4487 plumbing_response.rate_limit) 4488 return resp 4489 4490 def list(self, filter, *args, timeout=None): 4491 ''' 4492 List gets a list of ProxyClusterKeys matching a given set of criteria. 4493 ''' 4494 deadline = None if timeout is None else time.time() + timeout 4495 req = ProxyClusterKeyListRequest() 4496 req.meta.CopyFrom(ListRequestMetadata()) 4497 if self.parent.page_limit > 0: 4498 req.meta.limit = self.parent.page_limit 4499 if self.parent.snapshot_datetime is not None: 4500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4501 4502 req.filter = plumbing.quote_filter_args(filter, *args) 4503 4504 def generator(svc, req): 4505 tries = 0 4506 while True: 4507 t = None if deadline is None else deadline - time.time() 4508 try: 4509 plumbing_response = svc.stub.List( 4510 req, 4511 metadata=svc.parent.get_metadata( 4512 'ProxyClusterKeys.List', req), 4513 timeout=t) 4514 except Exception as e: 4515 if self.parent.shouldRetry(tries, e, deadline): 4516 tries += 1 4517 time.sleep( 4518 self.parent.exponentialBackoff(tries, deadline)) 4519 continue 4520 raise plumbing.convert_error_to_porcelain(e) from e 4521 tries = 0 4522 for plumbing_item in plumbing_response.proxy_cluster_keys: 4523 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4524 plumbing_item) 4525 if plumbing_response.meta.next_cursor == '': 4526 break 4527 req.meta.cursor = plumbing_response.meta.next_cursor 4528 4529 return generator(self, req) 4530 4531 4532class SnapshotProxyClusterKeys: 4533 ''' 4534 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4535 service for historical queries. 4536 ''' 4537 def __init__(self, proxy_cluster_keys): 4538 self.proxy_cluster_keys = proxy_cluster_keys 4539 4540 def get(self, id, timeout=None): 4541 ''' 4542 Get reads one ProxyClusterKey by ID. 4543 ''' 4544 return self.proxy_cluster_keys.get(id, timeout=timeout) 4545 4546 def list(self, filter, *args, timeout=None): 4547 ''' 4548 List gets a list of ProxyClusterKeys matching a given set of criteria. 4549 ''' 4550 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 4551 4552 4553class Queries: 4554 ''' 4555 A Query is a record of a single client request to a resource, such as a SQL query. 4556 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4557 The Queries service is read-only. 4558 See `strongdm.models.Query`. 4559 ''' 4560 def __init__(self, channel, client): 4561 self.parent = client 4562 self.stub = QueriesStub(channel) 4563 4564 def list(self, filter, *args, timeout=None): 4565 ''' 4566 List gets a list of Queries matching a given set of criteria. 4567 ''' 4568 deadline = None if timeout is None else time.time() + timeout 4569 req = QueryListRequest() 4570 req.meta.CopyFrom(ListRequestMetadata()) 4571 if self.parent.page_limit > 0: 4572 req.meta.limit = self.parent.page_limit 4573 if self.parent.snapshot_datetime is not None: 4574 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4575 4576 req.filter = plumbing.quote_filter_args(filter, *args) 4577 4578 def generator(svc, req): 4579 tries = 0 4580 while True: 4581 t = None if deadline is None else deadline - time.time() 4582 try: 4583 plumbing_response = svc.stub.List( 4584 req, 4585 metadata=svc.parent.get_metadata('Queries.List', req), 4586 timeout=t) 4587 except Exception as e: 4588 if self.parent.shouldRetry(tries, e, deadline): 4589 tries += 1 4590 time.sleep( 4591 self.parent.exponentialBackoff(tries, deadline)) 4592 continue 4593 raise plumbing.convert_error_to_porcelain(e) from e 4594 tries = 0 4595 for plumbing_item in plumbing_response.queries: 4596 yield plumbing.convert_query_to_porcelain(plumbing_item) 4597 if plumbing_response.meta.next_cursor == '': 4598 break 4599 req.meta.cursor = plumbing_response.meta.next_cursor 4600 4601 return generator(self, req) 4602 4603 4604class RemoteIdentities: 4605 ''' 4606 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4607 See `strongdm.models.RemoteIdentity`. 4608 ''' 4609 def __init__(self, channel, client): 4610 self.parent = client 4611 self.stub = RemoteIdentitiesStub(channel) 4612 4613 def create(self, remote_identity, timeout=None): 4614 ''' 4615 Create registers a new RemoteIdentity. 4616 ''' 4617 deadline = None if timeout is None else time.time() + timeout 4618 req = RemoteIdentityCreateRequest() 4619 4620 if remote_identity is not None: 4621 req.remote_identity.CopyFrom( 4622 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4623 tries = 0 4624 plumbing_response = None 4625 while True: 4626 t = None if deadline is None else deadline - time.time() 4627 try: 4628 plumbing_response = self.stub.Create( 4629 req, 4630 metadata=self.parent.get_metadata( 4631 'RemoteIdentities.Create', req), 4632 timeout=t) 4633 except Exception as e: 4634 if self.parent.shouldRetry(tries, e, deadline): 4635 tries += 1 4636 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4637 continue 4638 raise plumbing.convert_error_to_porcelain(e) from e 4639 break 4640 4641 resp = models.RemoteIdentityCreateResponse() 4642 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4643 plumbing_response.meta) 4644 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4645 plumbing_response.rate_limit) 4646 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4647 plumbing_response.remote_identity) 4648 return resp 4649 4650 def get(self, id, timeout=None): 4651 ''' 4652 Get reads one RemoteIdentity by ID. 4653 ''' 4654 deadline = None if timeout is None else time.time() + timeout 4655 req = RemoteIdentityGetRequest() 4656 if self.parent.snapshot_datetime is not None: 4657 req.meta.CopyFrom(GetRequestMetadata()) 4658 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4659 4660 req.id = (id) 4661 tries = 0 4662 plumbing_response = None 4663 while True: 4664 t = None if deadline is None else deadline - time.time() 4665 try: 4666 plumbing_response = self.stub.Get( 4667 req, 4668 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4669 req), 4670 timeout=t) 4671 except Exception as e: 4672 if self.parent.shouldRetry(tries, e, deadline): 4673 tries += 1 4674 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4675 continue 4676 raise plumbing.convert_error_to_porcelain(e) from e 4677 break 4678 4679 resp = models.RemoteIdentityGetResponse() 4680 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4681 plumbing_response.meta) 4682 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4683 plumbing_response.rate_limit) 4684 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4685 plumbing_response.remote_identity) 4686 return resp 4687 4688 def update(self, remote_identity, timeout=None): 4689 ''' 4690 Update replaces all the fields of a RemoteIdentity by ID. 4691 ''' 4692 deadline = None if timeout is None else time.time() + timeout 4693 req = RemoteIdentityUpdateRequest() 4694 4695 if remote_identity is not None: 4696 req.remote_identity.CopyFrom( 4697 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4698 tries = 0 4699 plumbing_response = None 4700 while True: 4701 t = None if deadline is None else deadline - time.time() 4702 try: 4703 plumbing_response = self.stub.Update( 4704 req, 4705 metadata=self.parent.get_metadata( 4706 'RemoteIdentities.Update', req), 4707 timeout=t) 4708 except Exception as e: 4709 if self.parent.shouldRetry(tries, e, deadline): 4710 tries += 1 4711 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4712 continue 4713 raise plumbing.convert_error_to_porcelain(e) from e 4714 break 4715 4716 resp = models.RemoteIdentityUpdateResponse() 4717 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4718 plumbing_response.meta) 4719 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4720 plumbing_response.rate_limit) 4721 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4722 plumbing_response.remote_identity) 4723 return resp 4724 4725 def delete(self, id, timeout=None): 4726 ''' 4727 Delete removes a RemoteIdentity by ID. 4728 ''' 4729 deadline = None if timeout is None else time.time() + timeout 4730 req = RemoteIdentityDeleteRequest() 4731 4732 req.id = (id) 4733 tries = 0 4734 plumbing_response = None 4735 while True: 4736 t = None if deadline is None else deadline - time.time() 4737 try: 4738 plumbing_response = self.stub.Delete( 4739 req, 4740 metadata=self.parent.get_metadata( 4741 'RemoteIdentities.Delete', req), 4742 timeout=t) 4743 except Exception as e: 4744 if self.parent.shouldRetry(tries, e, deadline): 4745 tries += 1 4746 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4747 continue 4748 raise plumbing.convert_error_to_porcelain(e) from e 4749 break 4750 4751 resp = models.RemoteIdentityDeleteResponse() 4752 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4753 plumbing_response.meta) 4754 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4755 plumbing_response.rate_limit) 4756 return resp 4757 4758 def list(self, filter, *args, timeout=None): 4759 ''' 4760 List gets a list of RemoteIdentities matching a given set of criteria. 4761 ''' 4762 deadline = None if timeout is None else time.time() + timeout 4763 req = RemoteIdentityListRequest() 4764 req.meta.CopyFrom(ListRequestMetadata()) 4765 if self.parent.page_limit > 0: 4766 req.meta.limit = self.parent.page_limit 4767 if self.parent.snapshot_datetime is not None: 4768 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4769 4770 req.filter = plumbing.quote_filter_args(filter, *args) 4771 4772 def generator(svc, req): 4773 tries = 0 4774 while True: 4775 t = None if deadline is None else deadline - time.time() 4776 try: 4777 plumbing_response = svc.stub.List( 4778 req, 4779 metadata=svc.parent.get_metadata( 4780 'RemoteIdentities.List', req), 4781 timeout=t) 4782 except Exception as e: 4783 if self.parent.shouldRetry(tries, e, deadline): 4784 tries += 1 4785 time.sleep( 4786 self.parent.exponentialBackoff(tries, deadline)) 4787 continue 4788 raise plumbing.convert_error_to_porcelain(e) from e 4789 tries = 0 4790 for plumbing_item in plumbing_response.remote_identities: 4791 yield plumbing.convert_remote_identity_to_porcelain( 4792 plumbing_item) 4793 if plumbing_response.meta.next_cursor == '': 4794 break 4795 req.meta.cursor = plumbing_response.meta.next_cursor 4796 4797 return generator(self, req) 4798 4799 4800class SnapshotRemoteIdentities: 4801 ''' 4802 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 4803 service for historical queries. 4804 ''' 4805 def __init__(self, remote_identities): 4806 self.remote_identities = remote_identities 4807 4808 def get(self, id, timeout=None): 4809 ''' 4810 Get reads one RemoteIdentity by ID. 4811 ''' 4812 return self.remote_identities.get(id, timeout=timeout) 4813 4814 def list(self, filter, *args, timeout=None): 4815 ''' 4816 List gets a list of RemoteIdentities matching a given set of criteria. 4817 ''' 4818 return self.remote_identities.list(filter, *args, timeout=timeout) 4819 4820 4821class RemoteIdentitiesHistory: 4822 ''' 4823 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 4824 See `strongdm.models.RemoteIdentityHistory`. 4825 ''' 4826 def __init__(self, channel, client): 4827 self.parent = client 4828 self.stub = RemoteIdentitiesHistoryStub(channel) 4829 4830 def list(self, filter, *args, timeout=None): 4831 ''' 4832 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4833 ''' 4834 deadline = None if timeout is None else time.time() + timeout 4835 req = RemoteIdentityHistoryListRequest() 4836 req.meta.CopyFrom(ListRequestMetadata()) 4837 if self.parent.page_limit > 0: 4838 req.meta.limit = self.parent.page_limit 4839 if self.parent.snapshot_datetime is not None: 4840 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4841 4842 req.filter = plumbing.quote_filter_args(filter, *args) 4843 4844 def generator(svc, req): 4845 tries = 0 4846 while True: 4847 t = None if deadline is None else deadline - time.time() 4848 try: 4849 plumbing_response = svc.stub.List( 4850 req, 4851 metadata=svc.parent.get_metadata( 4852 'RemoteIdentitiesHistory.List', req), 4853 timeout=t) 4854 except Exception as e: 4855 if self.parent.shouldRetry(tries, e, deadline): 4856 tries += 1 4857 time.sleep( 4858 self.parent.exponentialBackoff(tries, deadline)) 4859 continue 4860 raise plumbing.convert_error_to_porcelain(e) from e 4861 tries = 0 4862 for plumbing_item in plumbing_response.history: 4863 yield plumbing.convert_remote_identity_history_to_porcelain( 4864 plumbing_item) 4865 if plumbing_response.meta.next_cursor == '': 4866 break 4867 req.meta.cursor = plumbing_response.meta.next_cursor 4868 4869 return generator(self, req) 4870 4871 4872class RemoteIdentityGroups: 4873 ''' 4874 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 4875 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 4876 See `strongdm.models.RemoteIdentityGroup`. 4877 ''' 4878 def __init__(self, channel, client): 4879 self.parent = client 4880 self.stub = RemoteIdentityGroupsStub(channel) 4881 4882 def get(self, id, timeout=None): 4883 ''' 4884 Get reads one RemoteIdentityGroup by ID. 4885 ''' 4886 deadline = None if timeout is None else time.time() + timeout 4887 req = RemoteIdentityGroupGetRequest() 4888 if self.parent.snapshot_datetime is not None: 4889 req.meta.CopyFrom(GetRequestMetadata()) 4890 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4891 4892 req.id = (id) 4893 tries = 0 4894 plumbing_response = None 4895 while True: 4896 t = None if deadline is None else deadline - time.time() 4897 try: 4898 plumbing_response = self.stub.Get( 4899 req, 4900 metadata=self.parent.get_metadata( 4901 'RemoteIdentityGroups.Get', req), 4902 timeout=t) 4903 except Exception as e: 4904 if self.parent.shouldRetry(tries, e, deadline): 4905 tries += 1 4906 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4907 continue 4908 raise plumbing.convert_error_to_porcelain(e) from e 4909 break 4910 4911 resp = models.RemoteIdentityGroupGetResponse() 4912 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4913 plumbing_response.meta) 4914 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4915 plumbing_response.rate_limit) 4916 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4917 plumbing_response.remote_identity_group) 4918 return resp 4919 4920 def list(self, filter, *args, timeout=None): 4921 ''' 4922 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4923 ''' 4924 deadline = None if timeout is None else time.time() + timeout 4925 req = RemoteIdentityGroupListRequest() 4926 req.meta.CopyFrom(ListRequestMetadata()) 4927 if self.parent.page_limit > 0: 4928 req.meta.limit = self.parent.page_limit 4929 if self.parent.snapshot_datetime is not None: 4930 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4931 4932 req.filter = plumbing.quote_filter_args(filter, *args) 4933 4934 def generator(svc, req): 4935 tries = 0 4936 while True: 4937 t = None if deadline is None else deadline - time.time() 4938 try: 4939 plumbing_response = svc.stub.List( 4940 req, 4941 metadata=svc.parent.get_metadata( 4942 'RemoteIdentityGroups.List', req), 4943 timeout=t) 4944 except Exception as e: 4945 if self.parent.shouldRetry(tries, e, deadline): 4946 tries += 1 4947 time.sleep( 4948 self.parent.exponentialBackoff(tries, deadline)) 4949 continue 4950 raise plumbing.convert_error_to_porcelain(e) from e 4951 tries = 0 4952 for plumbing_item in plumbing_response.remote_identity_groups: 4953 yield plumbing.convert_remote_identity_group_to_porcelain( 4954 plumbing_item) 4955 if plumbing_response.meta.next_cursor == '': 4956 break 4957 req.meta.cursor = plumbing_response.meta.next_cursor 4958 4959 return generator(self, req) 4960 4961 4962class SnapshotRemoteIdentityGroups: 4963 ''' 4964 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 4965 service for historical queries. 4966 ''' 4967 def __init__(self, remote_identity_groups): 4968 self.remote_identity_groups = remote_identity_groups 4969 4970 def get(self, id, timeout=None): 4971 ''' 4972 Get reads one RemoteIdentityGroup by ID. 4973 ''' 4974 return self.remote_identity_groups.get(id, timeout=timeout) 4975 4976 def list(self, filter, *args, timeout=None): 4977 ''' 4978 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4979 ''' 4980 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 4981 4982 4983class RemoteIdentityGroupsHistory: 4984 ''' 4985 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 4986 See `strongdm.models.RemoteIdentityGroupHistory`. 4987 ''' 4988 def __init__(self, channel, client): 4989 self.parent = client 4990 self.stub = RemoteIdentityGroupsHistoryStub(channel) 4991 4992 def list(self, filter, *args, timeout=None): 4993 ''' 4994 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4995 ''' 4996 deadline = None if timeout is None else time.time() + timeout 4997 req = RemoteIdentityGroupHistoryListRequest() 4998 req.meta.CopyFrom(ListRequestMetadata()) 4999 if self.parent.page_limit > 0: 5000 req.meta.limit = self.parent.page_limit 5001 if self.parent.snapshot_datetime is not None: 5002 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5003 5004 req.filter = plumbing.quote_filter_args(filter, *args) 5005 5006 def generator(svc, req): 5007 tries = 0 5008 while True: 5009 t = None if deadline is None else deadline - time.time() 5010 try: 5011 plumbing_response = svc.stub.List( 5012 req, 5013 metadata=svc.parent.get_metadata( 5014 'RemoteIdentityGroupsHistory.List', req), 5015 timeout=t) 5016 except Exception as e: 5017 if self.parent.shouldRetry(tries, e, deadline): 5018 tries += 1 5019 time.sleep( 5020 self.parent.exponentialBackoff(tries, deadline)) 5021 continue 5022 raise plumbing.convert_error_to_porcelain(e) from e 5023 tries = 0 5024 for plumbing_item in plumbing_response.history: 5025 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5026 plumbing_item) 5027 if plumbing_response.meta.next_cursor == '': 5028 break 5029 req.meta.cursor = plumbing_response.meta.next_cursor 5030 5031 return generator(self, req) 5032 5033 5034class Replays: 5035 ''' 5036 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5037 (otherwise referred to as a query). The Replays service is read-only. 5038 See `strongdm.models.ReplayChunk`. 5039 ''' 5040 def __init__(self, channel, client): 5041 self.parent = client 5042 self.stub = ReplaysStub(channel) 5043 5044 def list(self, filter, *args, timeout=None): 5045 ''' 5046 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5047 ''' 5048 deadline = None if timeout is None else time.time() + timeout 5049 req = ReplayListRequest() 5050 req.meta.CopyFrom(ListRequestMetadata()) 5051 if self.parent.page_limit > 0: 5052 req.meta.limit = self.parent.page_limit 5053 if self.parent.snapshot_datetime is not None: 5054 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5055 5056 req.filter = plumbing.quote_filter_args(filter, *args) 5057 5058 def generator(svc, req): 5059 tries = 0 5060 while True: 5061 t = None if deadline is None else deadline - time.time() 5062 try: 5063 plumbing_response = svc.stub.List( 5064 req, 5065 metadata=svc.parent.get_metadata('Replays.List', req), 5066 timeout=t) 5067 except Exception as e: 5068 if self.parent.shouldRetry(tries, e, deadline): 5069 tries += 1 5070 time.sleep( 5071 self.parent.exponentialBackoff(tries, deadline)) 5072 continue 5073 raise plumbing.convert_error_to_porcelain(e) from e 5074 tries = 0 5075 for plumbing_item in plumbing_response.chunks: 5076 yield plumbing.convert_replay_chunk_to_porcelain( 5077 plumbing_item) 5078 if plumbing_response.meta.next_cursor == '': 5079 break 5080 req.meta.cursor = plumbing_response.meta.next_cursor 5081 5082 return generator(self, req) 5083 5084 5085class Resources: 5086 ''' 5087 Resources are databases, servers, clusters, websites, or clouds that strongDM 5088 delegates access to. 5089 See: 5090 `strongdm.models.Aerospike` 5091 `strongdm.models.AKS` 5092 `strongdm.models.AKSBasicAuth` 5093 `strongdm.models.AKSServiceAccount` 5094 `strongdm.models.AKSServiceAccountUserImpersonation` 5095 `strongdm.models.AKSUserImpersonation` 5096 `strongdm.models.AmazonEKS` 5097 `strongdm.models.AmazonEKSInstanceProfile` 5098 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5099 `strongdm.models.AmazonEKSUserImpersonation` 5100 `strongdm.models.AmazonES` 5101 `strongdm.models.AmazonESIAM` 5102 `strongdm.models.AmazonMQAMQP091` 5103 `strongdm.models.Athena` 5104 `strongdm.models.AthenaIAM` 5105 `strongdm.models.AuroraMysql` 5106 `strongdm.models.AuroraMysqlIAM` 5107 `strongdm.models.AuroraPostgres` 5108 `strongdm.models.AuroraPostgresIAM` 5109 `strongdm.models.AWS` 5110 `strongdm.models.AWSConsole` 5111 `strongdm.models.AWSConsoleStaticKeyPair` 5112 `strongdm.models.AWSInstanceProfile` 5113 `strongdm.models.Azure` 5114 `strongdm.models.AzureCertificate` 5115 `strongdm.models.AzureMysql` 5116 `strongdm.models.AzurePostgres` 5117 `strongdm.models.AzurePostgresManagedIdentity` 5118 `strongdm.models.BigQuery` 5119 `strongdm.models.Cassandra` 5120 `strongdm.models.Citus` 5121 `strongdm.models.ClickHouseHTTP` 5122 `strongdm.models.ClickHouseMySQL` 5123 `strongdm.models.ClickHouseTCP` 5124 `strongdm.models.Clustrix` 5125 `strongdm.models.Cockroach` 5126 `strongdm.models.CouchbaseDatabase` 5127 `strongdm.models.CouchbaseWebUI` 5128 `strongdm.models.DB2I` 5129 `strongdm.models.DB2LUW` 5130 `strongdm.models.DocumentDBHost` 5131 `strongdm.models.DocumentDBHostIAM` 5132 `strongdm.models.DocumentDBReplicaSet` 5133 `strongdm.models.DocumentDBReplicaSetIAM` 5134 `strongdm.models.Druid` 5135 `strongdm.models.DynamoDB` 5136 `strongdm.models.DynamoDBIAM` 5137 `strongdm.models.Elastic` 5138 `strongdm.models.ElasticacheRedis` 5139 `strongdm.models.GCP` 5140 `strongdm.models.GCPConsole` 5141 `strongdm.models.GCPWIF` 5142 `strongdm.models.GoogleGKE` 5143 `strongdm.models.GoogleGKEUserImpersonation` 5144 `strongdm.models.Greenplum` 5145 `strongdm.models.HTTPAuth` 5146 `strongdm.models.HTTPBasicAuth` 5147 `strongdm.models.HTTPNoAuth` 5148 `strongdm.models.Kubernetes` 5149 `strongdm.models.KubernetesBasicAuth` 5150 `strongdm.models.KubernetesPodIdentity` 5151 `strongdm.models.KubernetesServiceAccount` 5152 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5153 `strongdm.models.KubernetesUserImpersonation` 5154 `strongdm.models.Maria` 5155 `strongdm.models.Memcached` 5156 `strongdm.models.Memsql` 5157 `strongdm.models.MongoHost` 5158 `strongdm.models.MongoLegacyHost` 5159 `strongdm.models.MongoLegacyReplicaset` 5160 `strongdm.models.MongoReplicaSet` 5161 `strongdm.models.MongoShardedCluster` 5162 `strongdm.models.MTLSMysql` 5163 `strongdm.models.MTLSPostgres` 5164 `strongdm.models.Mysql` 5165 `strongdm.models.Neptune` 5166 `strongdm.models.NeptuneIAM` 5167 `strongdm.models.Oracle` 5168 `strongdm.models.OracleNNE` 5169 `strongdm.models.Postgres` 5170 `strongdm.models.Presto` 5171 `strongdm.models.RabbitMQAMQP091` 5172 `strongdm.models.RawTCP` 5173 `strongdm.models.RDP` 5174 `strongdm.models.RDPCert` 5175 `strongdm.models.RDSPostgresIAM` 5176 `strongdm.models.Redis` 5177 `strongdm.models.RedisCluster` 5178 `strongdm.models.Redshift` 5179 `strongdm.models.RedshiftIAM` 5180 `strongdm.models.RedshiftServerlessIAM` 5181 `strongdm.models.SingleStore` 5182 `strongdm.models.Snowflake` 5183 `strongdm.models.Snowsight` 5184 `strongdm.models.SQLServer` 5185 `strongdm.models.SQLServerAzureAD` 5186 `strongdm.models.SQLServerKerberosAD` 5187 `strongdm.models.SSH` 5188 `strongdm.models.SSHCert` 5189 `strongdm.models.SSHCustomerKey` 5190 `strongdm.models.SSHPassword` 5191 `strongdm.models.Sybase` 5192 `strongdm.models.SybaseIQ` 5193 `strongdm.models.Teradata` 5194 `strongdm.models.Trino` 5195 `strongdm.models.Vertica` 5196 ''' 5197 def __init__(self, channel, client): 5198 self.parent = client 5199 self.stub = ResourcesStub(channel) 5200 5201 def enumerate_tags(self, filter, *args, timeout=None): 5202 ''' 5203 EnumerateTags gets a list of the filter matching tags. 5204 ''' 5205 deadline = None if timeout is None else time.time() + timeout 5206 req = EnumerateTagsRequest() 5207 req.meta.CopyFrom(ListRequestMetadata()) 5208 if self.parent.page_limit > 0: 5209 req.meta.limit = self.parent.page_limit 5210 if self.parent.snapshot_datetime is not None: 5211 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5212 5213 req.filter = plumbing.quote_filter_args(filter, *args) 5214 5215 def generator(svc, req): 5216 tries = 0 5217 while True: 5218 t = None if deadline is None else deadline - time.time() 5219 try: 5220 plumbing_response = svc.stub.EnumerateTags( 5221 req, 5222 metadata=svc.parent.get_metadata( 5223 'Resources.EnumerateTags', req), 5224 timeout=t) 5225 except Exception as e: 5226 if self.parent.shouldRetry(tries, e, deadline): 5227 tries += 1 5228 time.sleep( 5229 self.parent.exponentialBackoff(tries, deadline)) 5230 continue 5231 raise plumbing.convert_error_to_porcelain(e) from e 5232 tries = 0 5233 for plumbing_item in plumbing_response.matches: 5234 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5235 if plumbing_response.meta.next_cursor == '': 5236 break 5237 req.meta.cursor = plumbing_response.meta.next_cursor 5238 5239 return generator(self, req) 5240 5241 def create(self, resource, timeout=None): 5242 ''' 5243 Create registers a new Resource. 5244 ''' 5245 deadline = None if timeout is None else time.time() + timeout 5246 req = ResourceCreateRequest() 5247 5248 if resource is not None: 5249 req.resource.CopyFrom( 5250 plumbing.convert_resource_to_plumbing(resource)) 5251 tries = 0 5252 plumbing_response = None 5253 while True: 5254 t = None if deadline is None else deadline - time.time() 5255 try: 5256 plumbing_response = self.stub.Create( 5257 req, 5258 metadata=self.parent.get_metadata('Resources.Create', req), 5259 timeout=t) 5260 except Exception as e: 5261 if self.parent.shouldRetry(tries, e, deadline): 5262 tries += 1 5263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5264 continue 5265 raise plumbing.convert_error_to_porcelain(e) from e 5266 break 5267 5268 resp = models.ResourceCreateResponse() 5269 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5270 plumbing_response.meta) 5271 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5272 plumbing_response.rate_limit) 5273 resp.resource = plumbing.convert_resource_to_porcelain( 5274 plumbing_response.resource) 5275 return resp 5276 5277 def get(self, id, timeout=None): 5278 ''' 5279 Get reads one Resource by ID. 5280 ''' 5281 deadline = None if timeout is None else time.time() + timeout 5282 req = ResourceGetRequest() 5283 if self.parent.snapshot_datetime is not None: 5284 req.meta.CopyFrom(GetRequestMetadata()) 5285 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5286 5287 req.id = (id) 5288 tries = 0 5289 plumbing_response = None 5290 while True: 5291 t = None if deadline is None else deadline - time.time() 5292 try: 5293 plumbing_response = self.stub.Get( 5294 req, 5295 metadata=self.parent.get_metadata('Resources.Get', req), 5296 timeout=t) 5297 except Exception as e: 5298 if self.parent.shouldRetry(tries, e, deadline): 5299 tries += 1 5300 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5301 continue 5302 raise plumbing.convert_error_to_porcelain(e) from e 5303 break 5304 5305 resp = models.ResourceGetResponse() 5306 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5307 plumbing_response.meta) 5308 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5309 plumbing_response.rate_limit) 5310 resp.resource = plumbing.convert_resource_to_porcelain( 5311 plumbing_response.resource) 5312 return resp 5313 5314 def update(self, resource, timeout=None): 5315 ''' 5316 Update replaces all the fields of a Resource by ID. 5317 ''' 5318 deadline = None if timeout is None else time.time() + timeout 5319 req = ResourceUpdateRequest() 5320 5321 if resource is not None: 5322 req.resource.CopyFrom( 5323 plumbing.convert_resource_to_plumbing(resource)) 5324 tries = 0 5325 plumbing_response = None 5326 while True: 5327 t = None if deadline is None else deadline - time.time() 5328 try: 5329 plumbing_response = self.stub.Update( 5330 req, 5331 metadata=self.parent.get_metadata('Resources.Update', req), 5332 timeout=t) 5333 except Exception as e: 5334 if self.parent.shouldRetry(tries, e, deadline): 5335 tries += 1 5336 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5337 continue 5338 raise plumbing.convert_error_to_porcelain(e) from e 5339 break 5340 5341 resp = models.ResourceUpdateResponse() 5342 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5343 plumbing_response.meta) 5344 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5345 plumbing_response.rate_limit) 5346 resp.resource = plumbing.convert_resource_to_porcelain( 5347 plumbing_response.resource) 5348 return resp 5349 5350 def delete(self, id, timeout=None): 5351 ''' 5352 Delete removes a Resource by ID. 5353 ''' 5354 deadline = None if timeout is None else time.time() + timeout 5355 req = ResourceDeleteRequest() 5356 5357 req.id = (id) 5358 tries = 0 5359 plumbing_response = None 5360 while True: 5361 t = None if deadline is None else deadline - time.time() 5362 try: 5363 plumbing_response = self.stub.Delete( 5364 req, 5365 metadata=self.parent.get_metadata('Resources.Delete', req), 5366 timeout=t) 5367 except Exception as e: 5368 if self.parent.shouldRetry(tries, e, deadline): 5369 tries += 1 5370 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5371 continue 5372 raise plumbing.convert_error_to_porcelain(e) from e 5373 break 5374 5375 resp = models.ResourceDeleteResponse() 5376 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5377 plumbing_response.meta) 5378 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5379 plumbing_response.rate_limit) 5380 return resp 5381 5382 def list(self, filter, *args, timeout=None): 5383 ''' 5384 List gets a list of Resources matching a given set of criteria. 5385 ''' 5386 deadline = None if timeout is None else time.time() + timeout 5387 req = ResourceListRequest() 5388 req.meta.CopyFrom(ListRequestMetadata()) 5389 if self.parent.page_limit > 0: 5390 req.meta.limit = self.parent.page_limit 5391 if self.parent.snapshot_datetime is not None: 5392 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5393 5394 req.filter = plumbing.quote_filter_args(filter, *args) 5395 5396 def generator(svc, req): 5397 tries = 0 5398 while True: 5399 t = None if deadline is None else deadline - time.time() 5400 try: 5401 plumbing_response = svc.stub.List( 5402 req, 5403 metadata=svc.parent.get_metadata( 5404 'Resources.List', req), 5405 timeout=t) 5406 except Exception as e: 5407 if self.parent.shouldRetry(tries, e, deadline): 5408 tries += 1 5409 time.sleep( 5410 self.parent.exponentialBackoff(tries, deadline)) 5411 continue 5412 raise plumbing.convert_error_to_porcelain(e) from e 5413 tries = 0 5414 for plumbing_item in plumbing_response.resources: 5415 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5416 if plumbing_response.meta.next_cursor == '': 5417 break 5418 req.meta.cursor = plumbing_response.meta.next_cursor 5419 5420 return generator(self, req) 5421 5422 def healthcheck(self, id, timeout=None): 5423 ''' 5424 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5425 large network of Nodes. The call will return immediately, and the updated health of the 5426 Resource can be retrieved via Get or List. 5427 ''' 5428 deadline = None if timeout is None else time.time() + timeout 5429 req = ResourceHealthcheckRequest() 5430 5431 req.id = (id) 5432 tries = 0 5433 plumbing_response = None 5434 while True: 5435 t = None if deadline is None else deadline - time.time() 5436 try: 5437 plumbing_response = self.stub.Healthcheck( 5438 req, 5439 metadata=self.parent.get_metadata('Resources.Healthcheck', 5440 req), 5441 timeout=t) 5442 except Exception as e: 5443 if self.parent.shouldRetry(tries, e, deadline): 5444 tries += 1 5445 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5446 continue 5447 raise plumbing.convert_error_to_porcelain(e) from e 5448 break 5449 5450 resp = models.ResourceHealthcheckResponse() 5451 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5452 plumbing_response.meta) 5453 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5454 plumbing_response.rate_limit) 5455 return resp 5456 5457 5458class SnapshotResources: 5459 ''' 5460 SnapshotResources exposes the read only methods of the Resources 5461 service for historical queries. 5462 ''' 5463 def __init__(self, resources): 5464 self.resources = resources 5465 5466 def get(self, id, timeout=None): 5467 ''' 5468 Get reads one Resource by ID. 5469 ''' 5470 return self.resources.get(id, timeout=timeout) 5471 5472 def list(self, filter, *args, timeout=None): 5473 ''' 5474 List gets a list of Resources matching a given set of criteria. 5475 ''' 5476 return self.resources.list(filter, *args, timeout=timeout) 5477 5478 5479class ResourcesHistory: 5480 ''' 5481 ResourcesHistory records all changes to the state of a Resource. 5482 See `strongdm.models.ResourceHistory`. 5483 ''' 5484 def __init__(self, channel, client): 5485 self.parent = client 5486 self.stub = ResourcesHistoryStub(channel) 5487 5488 def list(self, filter, *args, timeout=None): 5489 ''' 5490 List gets a list of ResourceHistory records matching a given set of criteria. 5491 ''' 5492 deadline = None if timeout is None else time.time() + timeout 5493 req = ResourceHistoryListRequest() 5494 req.meta.CopyFrom(ListRequestMetadata()) 5495 if self.parent.page_limit > 0: 5496 req.meta.limit = self.parent.page_limit 5497 if self.parent.snapshot_datetime is not None: 5498 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5499 5500 req.filter = plumbing.quote_filter_args(filter, *args) 5501 5502 def generator(svc, req): 5503 tries = 0 5504 while True: 5505 t = None if deadline is None else deadline - time.time() 5506 try: 5507 plumbing_response = svc.stub.List( 5508 req, 5509 metadata=svc.parent.get_metadata( 5510 'ResourcesHistory.List', req), 5511 timeout=t) 5512 except Exception as e: 5513 if self.parent.shouldRetry(tries, e, deadline): 5514 tries += 1 5515 time.sleep( 5516 self.parent.exponentialBackoff(tries, deadline)) 5517 continue 5518 raise plumbing.convert_error_to_porcelain(e) from e 5519 tries = 0 5520 for plumbing_item in plumbing_response.history: 5521 yield plumbing.convert_resource_history_to_porcelain( 5522 plumbing_item) 5523 if plumbing_response.meta.next_cursor == '': 5524 break 5525 req.meta.cursor = plumbing_response.meta.next_cursor 5526 5527 return generator(self, req) 5528 5529 5530class RoleResources: 5531 ''' 5532 RoleResources enumerates the resources to which roles have access. 5533 The RoleResources service is read-only. 5534 See `strongdm.models.RoleResource`. 5535 ''' 5536 def __init__(self, channel, client): 5537 self.parent = client 5538 self.stub = RoleResourcesStub(channel) 5539 5540 def list(self, filter, *args, timeout=None): 5541 ''' 5542 List gets a list of RoleResource records matching a given set of criteria. 5543 ''' 5544 deadline = None if timeout is None else time.time() + timeout 5545 req = RoleResourceListRequest() 5546 req.meta.CopyFrom(ListRequestMetadata()) 5547 if self.parent.page_limit > 0: 5548 req.meta.limit = self.parent.page_limit 5549 if self.parent.snapshot_datetime is not None: 5550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5551 5552 req.filter = plumbing.quote_filter_args(filter, *args) 5553 5554 def generator(svc, req): 5555 tries = 0 5556 while True: 5557 t = None if deadline is None else deadline - time.time() 5558 try: 5559 plumbing_response = svc.stub.List( 5560 req, 5561 metadata=svc.parent.get_metadata( 5562 'RoleResources.List', req), 5563 timeout=t) 5564 except Exception as e: 5565 if self.parent.shouldRetry(tries, e, deadline): 5566 tries += 1 5567 time.sleep( 5568 self.parent.exponentialBackoff(tries, deadline)) 5569 continue 5570 raise plumbing.convert_error_to_porcelain(e) from e 5571 tries = 0 5572 for plumbing_item in plumbing_response.role_resources: 5573 yield plumbing.convert_role_resource_to_porcelain( 5574 plumbing_item) 5575 if plumbing_response.meta.next_cursor == '': 5576 break 5577 req.meta.cursor = plumbing_response.meta.next_cursor 5578 5579 return generator(self, req) 5580 5581 5582class SnapshotRoleResources: 5583 ''' 5584 SnapshotRoleResources exposes the read only methods of the RoleResources 5585 service for historical queries. 5586 ''' 5587 def __init__(self, role_resources): 5588 self.role_resources = role_resources 5589 5590 def list(self, filter, *args, timeout=None): 5591 ''' 5592 List gets a list of RoleResource records matching a given set of criteria. 5593 ''' 5594 return self.role_resources.list(filter, *args, timeout=timeout) 5595 5596 5597class RoleResourcesHistory: 5598 ''' 5599 RoleResourcesHistory records all changes to the state of a RoleResource. 5600 See `strongdm.models.RoleResourceHistory`. 5601 ''' 5602 def __init__(self, channel, client): 5603 self.parent = client 5604 self.stub = RoleResourcesHistoryStub(channel) 5605 5606 def list(self, filter, *args, timeout=None): 5607 ''' 5608 List gets a list of RoleResourceHistory records matching a given set of criteria. 5609 ''' 5610 deadline = None if timeout is None else time.time() + timeout 5611 req = RoleResourceHistoryListRequest() 5612 req.meta.CopyFrom(ListRequestMetadata()) 5613 if self.parent.page_limit > 0: 5614 req.meta.limit = self.parent.page_limit 5615 if self.parent.snapshot_datetime is not None: 5616 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5617 5618 req.filter = plumbing.quote_filter_args(filter, *args) 5619 5620 def generator(svc, req): 5621 tries = 0 5622 while True: 5623 t = None if deadline is None else deadline - time.time() 5624 try: 5625 plumbing_response = svc.stub.List( 5626 req, 5627 metadata=svc.parent.get_metadata( 5628 'RoleResourcesHistory.List', req), 5629 timeout=t) 5630 except Exception as e: 5631 if self.parent.shouldRetry(tries, e, deadline): 5632 tries += 1 5633 time.sleep( 5634 self.parent.exponentialBackoff(tries, deadline)) 5635 continue 5636 raise plumbing.convert_error_to_porcelain(e) from e 5637 tries = 0 5638 for plumbing_item in plumbing_response.history: 5639 yield plumbing.convert_role_resource_history_to_porcelain( 5640 plumbing_item) 5641 if plumbing_response.meta.next_cursor == '': 5642 break 5643 req.meta.cursor = plumbing_response.meta.next_cursor 5644 5645 return generator(self, req) 5646 5647 5648class Roles: 5649 ''' 5650 A Role has a list of access rules which determine which Resources the members 5651 of the Role have access to. An Account can be a member of multiple Roles via 5652 AccountAttachments. 5653 See `strongdm.models.Role`. 5654 ''' 5655 def __init__(self, channel, client): 5656 self.parent = client 5657 self.stub = RolesStub(channel) 5658 5659 def create(self, role, timeout=None): 5660 ''' 5661 Create registers a new Role. 5662 ''' 5663 deadline = None if timeout is None else time.time() + timeout 5664 req = RoleCreateRequest() 5665 5666 if role is not None: 5667 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5668 tries = 0 5669 plumbing_response = None 5670 while True: 5671 t = None if deadline is None else deadline - time.time() 5672 try: 5673 plumbing_response = self.stub.Create( 5674 req, 5675 metadata=self.parent.get_metadata('Roles.Create', req), 5676 timeout=t) 5677 except Exception as e: 5678 if self.parent.shouldRetry(tries, e, deadline): 5679 tries += 1 5680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5681 continue 5682 raise plumbing.convert_error_to_porcelain(e) from e 5683 break 5684 5685 resp = models.RoleCreateResponse() 5686 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5687 plumbing_response.meta) 5688 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5689 plumbing_response.rate_limit) 5690 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5691 return resp 5692 5693 def get(self, id, timeout=None): 5694 ''' 5695 Get reads one Role by ID. 5696 ''' 5697 deadline = None if timeout is None else time.time() + timeout 5698 req = RoleGetRequest() 5699 if self.parent.snapshot_datetime is not None: 5700 req.meta.CopyFrom(GetRequestMetadata()) 5701 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5702 5703 req.id = (id) 5704 tries = 0 5705 plumbing_response = None 5706 while True: 5707 t = None if deadline is None else deadline - time.time() 5708 try: 5709 plumbing_response = self.stub.Get( 5710 req, 5711 metadata=self.parent.get_metadata('Roles.Get', req), 5712 timeout=t) 5713 except Exception as e: 5714 if self.parent.shouldRetry(tries, e, deadline): 5715 tries += 1 5716 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5717 continue 5718 raise plumbing.convert_error_to_porcelain(e) from e 5719 break 5720 5721 resp = models.RoleGetResponse() 5722 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5723 plumbing_response.meta) 5724 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5725 plumbing_response.rate_limit) 5726 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5727 return resp 5728 5729 def update(self, role, timeout=None): 5730 ''' 5731 Update replaces all the fields of a Role by ID. 5732 ''' 5733 deadline = None if timeout is None else time.time() + timeout 5734 req = RoleUpdateRequest() 5735 5736 if role is not None: 5737 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5738 tries = 0 5739 plumbing_response = None 5740 while True: 5741 t = None if deadline is None else deadline - time.time() 5742 try: 5743 plumbing_response = self.stub.Update( 5744 req, 5745 metadata=self.parent.get_metadata('Roles.Update', req), 5746 timeout=t) 5747 except Exception as e: 5748 if self.parent.shouldRetry(tries, e, deadline): 5749 tries += 1 5750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5751 continue 5752 raise plumbing.convert_error_to_porcelain(e) from e 5753 break 5754 5755 resp = models.RoleUpdateResponse() 5756 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5757 plumbing_response.meta) 5758 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5759 plumbing_response.rate_limit) 5760 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5761 return resp 5762 5763 def delete(self, id, timeout=None): 5764 ''' 5765 Delete removes a Role by ID. 5766 ''' 5767 deadline = None if timeout is None else time.time() + timeout 5768 req = RoleDeleteRequest() 5769 5770 req.id = (id) 5771 tries = 0 5772 plumbing_response = None 5773 while True: 5774 t = None if deadline is None else deadline - time.time() 5775 try: 5776 plumbing_response = self.stub.Delete( 5777 req, 5778 metadata=self.parent.get_metadata('Roles.Delete', req), 5779 timeout=t) 5780 except Exception as e: 5781 if self.parent.shouldRetry(tries, e, deadline): 5782 tries += 1 5783 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5784 continue 5785 raise plumbing.convert_error_to_porcelain(e) from e 5786 break 5787 5788 resp = models.RoleDeleteResponse() 5789 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5790 plumbing_response.meta) 5791 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5792 plumbing_response.rate_limit) 5793 return resp 5794 5795 def list(self, filter, *args, timeout=None): 5796 ''' 5797 List gets a list of Roles matching a given set of criteria. 5798 ''' 5799 deadline = None if timeout is None else time.time() + timeout 5800 req = RoleListRequest() 5801 req.meta.CopyFrom(ListRequestMetadata()) 5802 if self.parent.page_limit > 0: 5803 req.meta.limit = self.parent.page_limit 5804 if self.parent.snapshot_datetime is not None: 5805 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5806 5807 req.filter = plumbing.quote_filter_args(filter, *args) 5808 5809 def generator(svc, req): 5810 tries = 0 5811 while True: 5812 t = None if deadline is None else deadline - time.time() 5813 try: 5814 plumbing_response = svc.stub.List( 5815 req, 5816 metadata=svc.parent.get_metadata('Roles.List', req), 5817 timeout=t) 5818 except Exception as e: 5819 if self.parent.shouldRetry(tries, e, deadline): 5820 tries += 1 5821 time.sleep( 5822 self.parent.exponentialBackoff(tries, deadline)) 5823 continue 5824 raise plumbing.convert_error_to_porcelain(e) from e 5825 tries = 0 5826 for plumbing_item in plumbing_response.roles: 5827 yield plumbing.convert_role_to_porcelain(plumbing_item) 5828 if plumbing_response.meta.next_cursor == '': 5829 break 5830 req.meta.cursor = plumbing_response.meta.next_cursor 5831 5832 return generator(self, req) 5833 5834 5835class SnapshotRoles: 5836 ''' 5837 SnapshotRoles exposes the read only methods of the Roles 5838 service for historical queries. 5839 ''' 5840 def __init__(self, roles): 5841 self.roles = roles 5842 5843 def get(self, id, timeout=None): 5844 ''' 5845 Get reads one Role by ID. 5846 ''' 5847 return self.roles.get(id, timeout=timeout) 5848 5849 def list(self, filter, *args, timeout=None): 5850 ''' 5851 List gets a list of Roles matching a given set of criteria. 5852 ''' 5853 return self.roles.list(filter, *args, timeout=timeout) 5854 5855 5856class RolesHistory: 5857 ''' 5858 RolesHistory records all changes to the state of a Role. 5859 See `strongdm.models.RoleHistory`. 5860 ''' 5861 def __init__(self, channel, client): 5862 self.parent = client 5863 self.stub = RolesHistoryStub(channel) 5864 5865 def list(self, filter, *args, timeout=None): 5866 ''' 5867 List gets a list of RoleHistory records matching a given set of criteria. 5868 ''' 5869 deadline = None if timeout is None else time.time() + timeout 5870 req = RoleHistoryListRequest() 5871 req.meta.CopyFrom(ListRequestMetadata()) 5872 if self.parent.page_limit > 0: 5873 req.meta.limit = self.parent.page_limit 5874 if self.parent.snapshot_datetime is not None: 5875 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5876 5877 req.filter = plumbing.quote_filter_args(filter, *args) 5878 5879 def generator(svc, req): 5880 tries = 0 5881 while True: 5882 t = None if deadline is None else deadline - time.time() 5883 try: 5884 plumbing_response = svc.stub.List( 5885 req, 5886 metadata=svc.parent.get_metadata( 5887 'RolesHistory.List', req), 5888 timeout=t) 5889 except Exception as e: 5890 if self.parent.shouldRetry(tries, e, deadline): 5891 tries += 1 5892 time.sleep( 5893 self.parent.exponentialBackoff(tries, deadline)) 5894 continue 5895 raise plumbing.convert_error_to_porcelain(e) from e 5896 tries = 0 5897 for plumbing_item in plumbing_response.history: 5898 yield plumbing.convert_role_history_to_porcelain( 5899 plumbing_item) 5900 if plumbing_response.meta.next_cursor == '': 5901 break 5902 req.meta.cursor = plumbing_response.meta.next_cursor 5903 5904 return generator(self, req) 5905 5906 5907class SecretStores: 5908 ''' 5909 SecretStores are servers where resource secrets (passwords, keys) are stored. 5910 See: 5911 `strongdm.models.ActiveDirectoryStore` 5912 `strongdm.models.AWSStore` 5913 `strongdm.models.AWSCertX509Store` 5914 `strongdm.models.AzureStore` 5915 `strongdm.models.CyberarkConjurStore` 5916 `strongdm.models.CyberarkPAMStore` 5917 `strongdm.models.CyberarkPAMExperimentalStore` 5918 `strongdm.models.DelineaStore` 5919 `strongdm.models.GCPStore` 5920 `strongdm.models.GCPCertX509Store` 5921 `strongdm.models.KeyfactorSSHStore` 5922 `strongdm.models.KeyfactorX509Store` 5923 `strongdm.models.VaultAppRoleStore` 5924 `strongdm.models.VaultAppRoleCertSSHStore` 5925 `strongdm.models.VaultAppRoleCertX509Store` 5926 `strongdm.models.VaultAWSEC2Store` 5927 `strongdm.models.VaultAWSIAMStore` 5928 `strongdm.models.VaultTLSStore` 5929 `strongdm.models.VaultTLSCertSSHStore` 5930 `strongdm.models.VaultTLSCertX509Store` 5931 `strongdm.models.VaultTokenStore` 5932 `strongdm.models.VaultTokenCertSSHStore` 5933 `strongdm.models.VaultTokenCertX509Store` 5934 ''' 5935 def __init__(self, channel, client): 5936 self.parent = client 5937 self.stub = SecretStoresStub(channel) 5938 5939 def create(self, secret_store, timeout=None): 5940 deadline = None if timeout is None else time.time() + timeout 5941 req = SecretStoreCreateRequest() 5942 5943 if secret_store is not None: 5944 req.secret_store.CopyFrom( 5945 plumbing.convert_secret_store_to_plumbing(secret_store)) 5946 tries = 0 5947 plumbing_response = None 5948 while True: 5949 t = None if deadline is None else deadline - time.time() 5950 try: 5951 plumbing_response = self.stub.Create( 5952 req, 5953 metadata=self.parent.get_metadata('SecretStores.Create', 5954 req), 5955 timeout=t) 5956 except Exception as e: 5957 if self.parent.shouldRetry(tries, e, deadline): 5958 tries += 1 5959 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5960 continue 5961 raise plumbing.convert_error_to_porcelain(e) from e 5962 break 5963 5964 resp = models.SecretStoreCreateResponse() 5965 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5966 plumbing_response.meta) 5967 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5968 plumbing_response.rate_limit) 5969 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5970 plumbing_response.secret_store) 5971 return resp 5972 5973 def get(self, id, timeout=None): 5974 ''' 5975 Get reads one SecretStore by ID. 5976 ''' 5977 deadline = None if timeout is None else time.time() + timeout 5978 req = SecretStoreGetRequest() 5979 if self.parent.snapshot_datetime is not None: 5980 req.meta.CopyFrom(GetRequestMetadata()) 5981 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5982 5983 req.id = (id) 5984 tries = 0 5985 plumbing_response = None 5986 while True: 5987 t = None if deadline is None else deadline - time.time() 5988 try: 5989 plumbing_response = self.stub.Get( 5990 req, 5991 metadata=self.parent.get_metadata('SecretStores.Get', req), 5992 timeout=t) 5993 except Exception as e: 5994 if self.parent.shouldRetry(tries, e, deadline): 5995 tries += 1 5996 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5997 continue 5998 raise plumbing.convert_error_to_porcelain(e) from e 5999 break 6000 6001 resp = models.SecretStoreGetResponse() 6002 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6003 plumbing_response.meta) 6004 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6005 plumbing_response.rate_limit) 6006 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6007 plumbing_response.secret_store) 6008 return resp 6009 6010 def update(self, secret_store, timeout=None): 6011 ''' 6012 Update replaces all the fields of a SecretStore by ID. 6013 ''' 6014 deadline = None if timeout is None else time.time() + timeout 6015 req = SecretStoreUpdateRequest() 6016 6017 if secret_store is not None: 6018 req.secret_store.CopyFrom( 6019 plumbing.convert_secret_store_to_plumbing(secret_store)) 6020 tries = 0 6021 plumbing_response = None 6022 while True: 6023 t = None if deadline is None else deadline - time.time() 6024 try: 6025 plumbing_response = self.stub.Update( 6026 req, 6027 metadata=self.parent.get_metadata('SecretStores.Update', 6028 req), 6029 timeout=t) 6030 except Exception as e: 6031 if self.parent.shouldRetry(tries, e, deadline): 6032 tries += 1 6033 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6034 continue 6035 raise plumbing.convert_error_to_porcelain(e) from e 6036 break 6037 6038 resp = models.SecretStoreUpdateResponse() 6039 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6040 plumbing_response.meta) 6041 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6042 plumbing_response.rate_limit) 6043 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6044 plumbing_response.secret_store) 6045 return resp 6046 6047 def delete(self, id, timeout=None): 6048 ''' 6049 Delete removes a SecretStore by ID. 6050 ''' 6051 deadline = None if timeout is None else time.time() + timeout 6052 req = SecretStoreDeleteRequest() 6053 6054 req.id = (id) 6055 tries = 0 6056 plumbing_response = None 6057 while True: 6058 t = None if deadline is None else deadline - time.time() 6059 try: 6060 plumbing_response = self.stub.Delete( 6061 req, 6062 metadata=self.parent.get_metadata('SecretStores.Delete', 6063 req), 6064 timeout=t) 6065 except Exception as e: 6066 if self.parent.shouldRetry(tries, e, deadline): 6067 tries += 1 6068 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6069 continue 6070 raise plumbing.convert_error_to_porcelain(e) from e 6071 break 6072 6073 resp = models.SecretStoreDeleteResponse() 6074 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6075 plumbing_response.meta) 6076 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6077 plumbing_response.rate_limit) 6078 return resp 6079 6080 def list(self, filter, *args, timeout=None): 6081 ''' 6082 List gets a list of SecretStores matching a given set of criteria. 6083 ''' 6084 deadline = None if timeout is None else time.time() + timeout 6085 req = SecretStoreListRequest() 6086 req.meta.CopyFrom(ListRequestMetadata()) 6087 if self.parent.page_limit > 0: 6088 req.meta.limit = self.parent.page_limit 6089 if self.parent.snapshot_datetime is not None: 6090 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6091 6092 req.filter = plumbing.quote_filter_args(filter, *args) 6093 6094 def generator(svc, req): 6095 tries = 0 6096 while True: 6097 t = None if deadline is None else deadline - time.time() 6098 try: 6099 plumbing_response = svc.stub.List( 6100 req, 6101 metadata=svc.parent.get_metadata( 6102 'SecretStores.List', req), 6103 timeout=t) 6104 except Exception as e: 6105 if self.parent.shouldRetry(tries, e, deadline): 6106 tries += 1 6107 time.sleep( 6108 self.parent.exponentialBackoff(tries, deadline)) 6109 continue 6110 raise plumbing.convert_error_to_porcelain(e) from e 6111 tries = 0 6112 for plumbing_item in plumbing_response.secret_stores: 6113 yield plumbing.convert_secret_store_to_porcelain( 6114 plumbing_item) 6115 if plumbing_response.meta.next_cursor == '': 6116 break 6117 req.meta.cursor = plumbing_response.meta.next_cursor 6118 6119 return generator(self, req) 6120 6121 6122class SnapshotSecretStores: 6123 ''' 6124 SnapshotSecretStores exposes the read only methods of the SecretStores 6125 service for historical queries. 6126 ''' 6127 def __init__(self, secret_stores): 6128 self.secret_stores = secret_stores 6129 6130 def get(self, id, timeout=None): 6131 ''' 6132 Get reads one SecretStore by ID. 6133 ''' 6134 return self.secret_stores.get(id, timeout=timeout) 6135 6136 def list(self, filter, *args, timeout=None): 6137 ''' 6138 List gets a list of SecretStores matching a given set of criteria. 6139 ''' 6140 return self.secret_stores.list(filter, *args, timeout=timeout) 6141 6142 6143class SecretEngines: 6144 ''' 6145 6146 See: 6147 `strongdm.models.ActiveDirectoryEngine` 6148 `strongdm.models.KeyValueEngine` 6149 ''' 6150 def __init__(self, channel, client): 6151 self.parent = client 6152 self.stub = SecretEnginesStub(channel) 6153 6154 def list(self, filter, *args, timeout=None): 6155 ''' 6156 List returns a list of Secret Engines 6157 ''' 6158 deadline = None if timeout is None else time.time() + timeout 6159 req = SecretEngineListRequest() 6160 req.meta.CopyFrom(ListRequestMetadata()) 6161 if self.parent.page_limit > 0: 6162 req.meta.limit = self.parent.page_limit 6163 if self.parent.snapshot_datetime is not None: 6164 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6165 6166 req.filter = plumbing.quote_filter_args(filter, *args) 6167 6168 def generator(svc, req): 6169 tries = 0 6170 while True: 6171 t = None if deadline is None else deadline - time.time() 6172 try: 6173 plumbing_response = svc.stub.List( 6174 req, 6175 metadata=svc.parent.get_metadata( 6176 'SecretEngines.List', req), 6177 timeout=t) 6178 except Exception as e: 6179 if self.parent.shouldRetry(tries, e, deadline): 6180 tries += 1 6181 time.sleep( 6182 self.parent.exponentialBackoff(tries, deadline)) 6183 continue 6184 raise plumbing.convert_error_to_porcelain(e) from e 6185 tries = 0 6186 for plumbing_item in plumbing_response.secret_engines: 6187 yield plumbing.convert_secret_engine_to_porcelain( 6188 plumbing_item) 6189 if plumbing_response.meta.next_cursor == '': 6190 break 6191 req.meta.cursor = plumbing_response.meta.next_cursor 6192 6193 return generator(self, req) 6194 6195 def get(self, id, timeout=None): 6196 ''' 6197 Get returns a secret engine details 6198 ''' 6199 deadline = None if timeout is None else time.time() + timeout 6200 req = SecretEngineGetRequest() 6201 if self.parent.snapshot_datetime is not None: 6202 req.meta.CopyFrom(GetRequestMetadata()) 6203 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6204 6205 req.id = (id) 6206 tries = 0 6207 plumbing_response = None 6208 while True: 6209 t = None if deadline is None else deadline - time.time() 6210 try: 6211 plumbing_response = self.stub.Get( 6212 req, 6213 metadata=self.parent.get_metadata('SecretEngines.Get', 6214 req), 6215 timeout=t) 6216 except Exception as e: 6217 if self.parent.shouldRetry(tries, e, deadline): 6218 tries += 1 6219 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6220 continue 6221 raise plumbing.convert_error_to_porcelain(e) from e 6222 break 6223 6224 resp = models.SecretEngineGetResponse() 6225 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6226 plumbing_response.meta) 6227 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6228 plumbing_response.rate_limit) 6229 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6230 plumbing_response.secret_engine) 6231 return resp 6232 6233 def create(self, secret_engine, timeout=None): 6234 ''' 6235 Create creates a secret engine 6236 ''' 6237 deadline = None if timeout is None else time.time() + timeout 6238 req = SecretEngineCreateRequest() 6239 6240 if secret_engine is not None: 6241 req.secret_engine.CopyFrom( 6242 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6243 tries = 0 6244 plumbing_response = None 6245 while True: 6246 t = None if deadline is None else deadline - time.time() 6247 try: 6248 plumbing_response = self.stub.Create( 6249 req, 6250 metadata=self.parent.get_metadata('SecretEngines.Create', 6251 req), 6252 timeout=t) 6253 except Exception as e: 6254 if self.parent.shouldRetry(tries, e, deadline): 6255 tries += 1 6256 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6257 continue 6258 raise plumbing.convert_error_to_porcelain(e) from e 6259 break 6260 6261 resp = models.SecretEngineCreateResponse() 6262 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6263 plumbing_response.meta) 6264 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6265 plumbing_response.rate_limit) 6266 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6267 plumbing_response.secret_engine) 6268 return resp 6269 6270 def update(self, secret_engine, timeout=None): 6271 ''' 6272 Update updates a secret engine 6273 ''' 6274 deadline = None if timeout is None else time.time() + timeout 6275 req = SecretEngineUpdateRequest() 6276 6277 if secret_engine is not None: 6278 req.secret_engine.CopyFrom( 6279 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6280 tries = 0 6281 plumbing_response = None 6282 while True: 6283 t = None if deadline is None else deadline - time.time() 6284 try: 6285 plumbing_response = self.stub.Update( 6286 req, 6287 metadata=self.parent.get_metadata('SecretEngines.Update', 6288 req), 6289 timeout=t) 6290 except Exception as e: 6291 if self.parent.shouldRetry(tries, e, deadline): 6292 tries += 1 6293 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6294 continue 6295 raise plumbing.convert_error_to_porcelain(e) from e 6296 break 6297 6298 resp = models.SecretEngineUpdateResponse() 6299 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6300 plumbing_response.meta) 6301 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6302 plumbing_response.rate_limit) 6303 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6304 plumbing_response.secret_engine) 6305 return resp 6306 6307 def delete(self, id, timeout=None): 6308 ''' 6309 Delete deletes a secret engine 6310 ''' 6311 deadline = None if timeout is None else time.time() + timeout 6312 req = SecretEngineDeleteRequest() 6313 6314 req.id = (id) 6315 tries = 0 6316 plumbing_response = None 6317 while True: 6318 t = None if deadline is None else deadline - time.time() 6319 try: 6320 plumbing_response = self.stub.Delete( 6321 req, 6322 metadata=self.parent.get_metadata('SecretEngines.Delete', 6323 req), 6324 timeout=t) 6325 except Exception as e: 6326 if self.parent.shouldRetry(tries, e, deadline): 6327 tries += 1 6328 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6329 continue 6330 raise plumbing.convert_error_to_porcelain(e) from e 6331 break 6332 6333 resp = models.SecretEngineDeleteResponse() 6334 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6335 plumbing_response.rate_limit) 6336 return resp 6337 6338 def list_secret_stores(self, filter, *args, timeout=None): 6339 ''' 6340 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6341 for Secret Engine 6342 ''' 6343 deadline = None if timeout is None else time.time() + timeout 6344 req = SecretStoreListRequest() 6345 req.meta.CopyFrom(ListRequestMetadata()) 6346 if self.parent.page_limit > 0: 6347 req.meta.limit = self.parent.page_limit 6348 if self.parent.snapshot_datetime is not None: 6349 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6350 6351 req.filter = plumbing.quote_filter_args(filter, *args) 6352 6353 def generator(svc, req): 6354 tries = 0 6355 while True: 6356 t = None if deadline is None else deadline - time.time() 6357 try: 6358 plumbing_response = svc.stub.ListSecretStores( 6359 req, 6360 metadata=svc.parent.get_metadata( 6361 'SecretEngines.ListSecretStores', req), 6362 timeout=t) 6363 except Exception as e: 6364 if self.parent.shouldRetry(tries, e, deadline): 6365 tries += 1 6366 time.sleep( 6367 self.parent.exponentialBackoff(tries, deadline)) 6368 continue 6369 raise plumbing.convert_error_to_porcelain(e) from e 6370 tries = 0 6371 for plumbing_item in plumbing_response.secret_stores: 6372 yield plumbing.convert_secret_store_to_porcelain( 6373 plumbing_item) 6374 if plumbing_response.meta.next_cursor == '': 6375 break 6376 req.meta.cursor = plumbing_response.meta.next_cursor 6377 6378 return generator(self, req) 6379 6380 def generate_keys(self, secret_engine_id, timeout=None): 6381 ''' 6382 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6383 ''' 6384 deadline = None if timeout is None else time.time() + timeout 6385 req = GenerateKeysRequest() 6386 6387 req.secret_engine_id = (secret_engine_id) 6388 tries = 0 6389 plumbing_response = None 6390 while True: 6391 t = None if deadline is None else deadline - time.time() 6392 try: 6393 plumbing_response = self.stub.GenerateKeys( 6394 req, 6395 metadata=self.parent.get_metadata( 6396 'SecretEngines.GenerateKeys', req), 6397 timeout=t) 6398 except Exception as e: 6399 if self.parent.shouldRetry(tries, e, deadline): 6400 tries += 1 6401 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6402 continue 6403 raise plumbing.convert_error_to_porcelain(e) from e 6404 break 6405 6406 resp = models.GenerateKeysResponse() 6407 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6408 plumbing_response.rate_limit) 6409 return resp 6410 6411 def healthcheck(self, secret_engine_id, timeout=None): 6412 ''' 6413 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6414 ''' 6415 deadline = None if timeout is None else time.time() + timeout 6416 req = HealthcheckRequest() 6417 6418 req.secret_engine_id = (secret_engine_id) 6419 tries = 0 6420 plumbing_response = None 6421 while True: 6422 t = None if deadline is None else deadline - time.time() 6423 try: 6424 plumbing_response = self.stub.Healthcheck( 6425 req, 6426 metadata=self.parent.get_metadata( 6427 'SecretEngines.Healthcheck', req), 6428 timeout=t) 6429 except Exception as e: 6430 if self.parent.shouldRetry(tries, e, deadline): 6431 tries += 1 6432 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6433 continue 6434 raise plumbing.convert_error_to_porcelain(e) from e 6435 break 6436 6437 resp = models.HealthcheckResponse() 6438 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6439 plumbing_response.rate_limit) 6440 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6441 plumbing_response.status) 6442 return resp 6443 6444 def rotate(self, id, password_policy, timeout=None): 6445 ''' 6446 Rotate rotates secret engine's credentials 6447 ''' 6448 deadline = None if timeout is None else time.time() + timeout 6449 req = SecretEngineRotateRequest() 6450 6451 req.id = (id) 6452 if password_policy is not None: 6453 req.password_policy.CopyFrom( 6454 plumbing.convert_secret_engine_password_policy_to_plumbing( 6455 password_policy)) 6456 tries = 0 6457 plumbing_response = None 6458 while True: 6459 t = None if deadline is None else deadline - time.time() 6460 try: 6461 plumbing_response = self.stub.Rotate( 6462 req, 6463 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6464 req), 6465 timeout=t) 6466 except Exception as e: 6467 if self.parent.shouldRetry(tries, e, deadline): 6468 tries += 1 6469 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6470 continue 6471 raise plumbing.convert_error_to_porcelain(e) from e 6472 break 6473 6474 resp = models.SecretEngineRotateResponse() 6475 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6476 plumbing_response.rate_limit) 6477 return resp 6478 6479 6480class SecretStoreHealths: 6481 ''' 6482 SecretStoreHealths exposes health states for secret stores. 6483 See `strongdm.models.SecretStoreHealth`. 6484 ''' 6485 def __init__(self, channel, client): 6486 self.parent = client 6487 self.stub = SecretStoreHealthsStub(channel) 6488 6489 def list(self, filter, *args, timeout=None): 6490 ''' 6491 List reports the health status of node to secret store pairs. 6492 ''' 6493 deadline = None if timeout is None else time.time() + timeout 6494 req = SecretStoreHealthListRequest() 6495 req.meta.CopyFrom(ListRequestMetadata()) 6496 if self.parent.page_limit > 0: 6497 req.meta.limit = self.parent.page_limit 6498 if self.parent.snapshot_datetime is not None: 6499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6500 6501 req.filter = plumbing.quote_filter_args(filter, *args) 6502 6503 def generator(svc, req): 6504 tries = 0 6505 while True: 6506 t = None if deadline is None else deadline - time.time() 6507 try: 6508 plumbing_response = svc.stub.List( 6509 req, 6510 metadata=svc.parent.get_metadata( 6511 'SecretStoreHealths.List', req), 6512 timeout=t) 6513 except Exception as e: 6514 if self.parent.shouldRetry(tries, e, deadline): 6515 tries += 1 6516 time.sleep( 6517 self.parent.exponentialBackoff(tries, deadline)) 6518 continue 6519 raise plumbing.convert_error_to_porcelain(e) from e 6520 tries = 0 6521 for plumbing_item in plumbing_response.secret_store_healths: 6522 yield plumbing.convert_secret_store_health_to_porcelain( 6523 plumbing_item) 6524 if plumbing_response.meta.next_cursor == '': 6525 break 6526 req.meta.cursor = plumbing_response.meta.next_cursor 6527 6528 return generator(self, req) 6529 6530 def healthcheck(self, secret_store_id, timeout=None): 6531 ''' 6532 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6533 to propagate across a large network of Nodes. The call will return immediately, and the 6534 updated health of the Secret Store can be retrieved via List. 6535 ''' 6536 deadline = None if timeout is None else time.time() + timeout 6537 req = SecretStoreHealthcheckRequest() 6538 6539 req.secret_store_id = (secret_store_id) 6540 tries = 0 6541 plumbing_response = None 6542 while True: 6543 t = None if deadline is None else deadline - time.time() 6544 try: 6545 plumbing_response = self.stub.Healthcheck( 6546 req, 6547 metadata=self.parent.get_metadata( 6548 'SecretStoreHealths.Healthcheck', req), 6549 timeout=t) 6550 except Exception as e: 6551 if self.parent.shouldRetry(tries, e, deadline): 6552 tries += 1 6553 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6554 continue 6555 raise plumbing.convert_error_to_porcelain(e) from e 6556 break 6557 6558 resp = models.SecretStoreHealthcheckResponse() 6559 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6560 plumbing_response.rate_limit) 6561 return resp 6562 6563 6564class SecretStoresHistory: 6565 ''' 6566 SecretStoresHistory records all changes to the state of a SecretStore. 6567 See `strongdm.models.SecretStoreHistory`. 6568 ''' 6569 def __init__(self, channel, client): 6570 self.parent = client 6571 self.stub = SecretStoresHistoryStub(channel) 6572 6573 def list(self, filter, *args, timeout=None): 6574 ''' 6575 List gets a list of SecretStoreHistory records matching a given set of criteria. 6576 ''' 6577 deadline = None if timeout is None else time.time() + timeout 6578 req = SecretStoreHistoryListRequest() 6579 req.meta.CopyFrom(ListRequestMetadata()) 6580 if self.parent.page_limit > 0: 6581 req.meta.limit = self.parent.page_limit 6582 if self.parent.snapshot_datetime is not None: 6583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6584 6585 req.filter = plumbing.quote_filter_args(filter, *args) 6586 6587 def generator(svc, req): 6588 tries = 0 6589 while True: 6590 t = None if deadline is None else deadline - time.time() 6591 try: 6592 plumbing_response = svc.stub.List( 6593 req, 6594 metadata=svc.parent.get_metadata( 6595 'SecretStoresHistory.List', req), 6596 timeout=t) 6597 except Exception as e: 6598 if self.parent.shouldRetry(tries, e, deadline): 6599 tries += 1 6600 time.sleep( 6601 self.parent.exponentialBackoff(tries, deadline)) 6602 continue 6603 raise plumbing.convert_error_to_porcelain(e) from e 6604 tries = 0 6605 for plumbing_item in plumbing_response.history: 6606 yield plumbing.convert_secret_store_history_to_porcelain( 6607 plumbing_item) 6608 if plumbing_response.meta.next_cursor == '': 6609 break 6610 req.meta.cursor = plumbing_response.meta.next_cursor 6611 6612 return generator(self, req) 6613 6614 6615class WorkflowApprovers: 6616 ''' 6617 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6618 See `strongdm.models.WorkflowApprover`. 6619 ''' 6620 def __init__(self, channel, client): 6621 self.parent = client 6622 self.stub = WorkflowApproversStub(channel) 6623 6624 def create(self, workflow_approver, timeout=None): 6625 ''' 6626 Create creates a new workflow approver 6627 ''' 6628 deadline = None if timeout is None else time.time() + timeout 6629 req = WorkflowApproversCreateRequest() 6630 6631 if workflow_approver is not None: 6632 req.workflow_approver.CopyFrom( 6633 plumbing.convert_workflow_approver_to_plumbing( 6634 workflow_approver)) 6635 tries = 0 6636 plumbing_response = None 6637 while True: 6638 t = None if deadline is None else deadline - time.time() 6639 try: 6640 plumbing_response = self.stub.Create( 6641 req, 6642 metadata=self.parent.get_metadata( 6643 'WorkflowApprovers.Create', req), 6644 timeout=t) 6645 except Exception as e: 6646 if self.parent.shouldRetry(tries, e, deadline): 6647 tries += 1 6648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6649 continue 6650 raise plumbing.convert_error_to_porcelain(e) from e 6651 break 6652 6653 resp = models.WorkflowApproversCreateResponse() 6654 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6655 plumbing_response.rate_limit) 6656 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6657 plumbing_response.workflow_approver) 6658 return resp 6659 6660 def get(self, id, timeout=None): 6661 ''' 6662 Get reads one workflow approver by ID. 6663 ''' 6664 deadline = None if timeout is None else time.time() + timeout 6665 req = WorkflowApproverGetRequest() 6666 if self.parent.snapshot_datetime is not None: 6667 req.meta.CopyFrom(GetRequestMetadata()) 6668 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6669 6670 req.id = (id) 6671 tries = 0 6672 plumbing_response = None 6673 while True: 6674 t = None if deadline is None else deadline - time.time() 6675 try: 6676 plumbing_response = self.stub.Get( 6677 req, 6678 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6679 req), 6680 timeout=t) 6681 except Exception as e: 6682 if self.parent.shouldRetry(tries, e, deadline): 6683 tries += 1 6684 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6685 continue 6686 raise plumbing.convert_error_to_porcelain(e) from e 6687 break 6688 6689 resp = models.WorkflowApproverGetResponse() 6690 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6691 plumbing_response.meta) 6692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6693 plumbing_response.rate_limit) 6694 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6695 plumbing_response.workflow_approver) 6696 return resp 6697 6698 def delete(self, id, timeout=None): 6699 ''' 6700 Delete deletes a workflow approver 6701 ''' 6702 deadline = None if timeout is None else time.time() + timeout 6703 req = WorkflowApproversDeleteRequest() 6704 6705 req.id = (id) 6706 tries = 0 6707 plumbing_response = None 6708 while True: 6709 t = None if deadline is None else deadline - time.time() 6710 try: 6711 plumbing_response = self.stub.Delete( 6712 req, 6713 metadata=self.parent.get_metadata( 6714 'WorkflowApprovers.Delete', req), 6715 timeout=t) 6716 except Exception as e: 6717 if self.parent.shouldRetry(tries, e, deadline): 6718 tries += 1 6719 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6720 continue 6721 raise plumbing.convert_error_to_porcelain(e) from e 6722 break 6723 6724 resp = models.WorkflowApproversDeleteResponse() 6725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6726 plumbing_response.rate_limit) 6727 return resp 6728 6729 def list(self, filter, *args, timeout=None): 6730 ''' 6731 Lists existing workflow approvers. 6732 ''' 6733 deadline = None if timeout is None else time.time() + timeout 6734 req = WorkflowApproversListRequest() 6735 req.meta.CopyFrom(ListRequestMetadata()) 6736 if self.parent.page_limit > 0: 6737 req.meta.limit = self.parent.page_limit 6738 if self.parent.snapshot_datetime is not None: 6739 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6740 6741 req.filter = plumbing.quote_filter_args(filter, *args) 6742 6743 def generator(svc, req): 6744 tries = 0 6745 while True: 6746 t = None if deadline is None else deadline - time.time() 6747 try: 6748 plumbing_response = svc.stub.List( 6749 req, 6750 metadata=svc.parent.get_metadata( 6751 'WorkflowApprovers.List', req), 6752 timeout=t) 6753 except Exception as e: 6754 if self.parent.shouldRetry(tries, e, deadline): 6755 tries += 1 6756 time.sleep( 6757 self.parent.exponentialBackoff(tries, deadline)) 6758 continue 6759 raise plumbing.convert_error_to_porcelain(e) from e 6760 tries = 0 6761 for plumbing_item in plumbing_response.workflow_approvers: 6762 yield plumbing.convert_workflow_approver_to_porcelain( 6763 plumbing_item) 6764 if plumbing_response.meta.next_cursor == '': 6765 break 6766 req.meta.cursor = plumbing_response.meta.next_cursor 6767 6768 return generator(self, req) 6769 6770 6771class SnapshotWorkflowApprovers: 6772 ''' 6773 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6774 service for historical queries. 6775 ''' 6776 def __init__(self, workflow_approvers): 6777 self.workflow_approvers = workflow_approvers 6778 6779 def get(self, id, timeout=None): 6780 ''' 6781 Get reads one workflow approver by ID. 6782 ''' 6783 return self.workflow_approvers.get(id, timeout=timeout) 6784 6785 def list(self, filter, *args, timeout=None): 6786 ''' 6787 Lists existing workflow approvers. 6788 ''' 6789 return self.workflow_approvers.list(filter, *args, timeout=timeout) 6790 6791 6792class WorkflowApproversHistory: 6793 ''' 6794 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6795 See `strongdm.models.WorkflowApproverHistory`. 6796 ''' 6797 def __init__(self, channel, client): 6798 self.parent = client 6799 self.stub = WorkflowApproversHistoryStub(channel) 6800 6801 def list(self, filter, *args, timeout=None): 6802 ''' 6803 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6804 ''' 6805 deadline = None if timeout is None else time.time() + timeout 6806 req = WorkflowApproversHistoryListRequest() 6807 req.meta.CopyFrom(ListRequestMetadata()) 6808 if self.parent.page_limit > 0: 6809 req.meta.limit = self.parent.page_limit 6810 if self.parent.snapshot_datetime is not None: 6811 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6812 6813 req.filter = plumbing.quote_filter_args(filter, *args) 6814 6815 def generator(svc, req): 6816 tries = 0 6817 while True: 6818 t = None if deadline is None else deadline - time.time() 6819 try: 6820 plumbing_response = svc.stub.List( 6821 req, 6822 metadata=svc.parent.get_metadata( 6823 'WorkflowApproversHistory.List', req), 6824 timeout=t) 6825 except Exception as e: 6826 if self.parent.shouldRetry(tries, e, deadline): 6827 tries += 1 6828 time.sleep( 6829 self.parent.exponentialBackoff(tries, deadline)) 6830 continue 6831 raise plumbing.convert_error_to_porcelain(e) from e 6832 tries = 0 6833 for plumbing_item in plumbing_response.history: 6834 yield plumbing.convert_workflow_approver_history_to_porcelain( 6835 plumbing_item) 6836 if plumbing_response.meta.next_cursor == '': 6837 break 6838 req.meta.cursor = plumbing_response.meta.next_cursor 6839 6840 return generator(self, req) 6841 6842 6843class WorkflowAssignments: 6844 ''' 6845 WorkflowAssignments links a Resource to a Workflow. The assigned resources are those that a user can request 6846 access to via the workflow. 6847 See `strongdm.models.WorkflowAssignment`. 6848 ''' 6849 def __init__(self, channel, client): 6850 self.parent = client 6851 self.stub = WorkflowAssignmentsStub(channel) 6852 6853 def list(self, filter, *args, timeout=None): 6854 ''' 6855 Lists existing workflow assignments. 6856 ''' 6857 deadline = None if timeout is None else time.time() + timeout 6858 req = WorkflowAssignmentsListRequest() 6859 req.meta.CopyFrom(ListRequestMetadata()) 6860 if self.parent.page_limit > 0: 6861 req.meta.limit = self.parent.page_limit 6862 if self.parent.snapshot_datetime is not None: 6863 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6864 6865 req.filter = plumbing.quote_filter_args(filter, *args) 6866 6867 def generator(svc, req): 6868 tries = 0 6869 while True: 6870 t = None if deadline is None else deadline - time.time() 6871 try: 6872 plumbing_response = svc.stub.List( 6873 req, 6874 metadata=svc.parent.get_metadata( 6875 'WorkflowAssignments.List', req), 6876 timeout=t) 6877 except Exception as e: 6878 if self.parent.shouldRetry(tries, e, deadline): 6879 tries += 1 6880 time.sleep( 6881 self.parent.exponentialBackoff(tries, deadline)) 6882 continue 6883 raise plumbing.convert_error_to_porcelain(e) from e 6884 tries = 0 6885 for plumbing_item in plumbing_response.workflow_assignments: 6886 yield plumbing.convert_workflow_assignment_to_porcelain( 6887 plumbing_item) 6888 if plumbing_response.meta.next_cursor == '': 6889 break 6890 req.meta.cursor = plumbing_response.meta.next_cursor 6891 6892 return generator(self, req) 6893 6894 6895class SnapshotWorkflowAssignments: 6896 ''' 6897 SnapshotWorkflowAssignments exposes the read only methods of the WorkflowAssignments 6898 service for historical queries. 6899 ''' 6900 def __init__(self, workflow_assignments): 6901 self.workflow_assignments = workflow_assignments 6902 6903 def list(self, filter, *args, timeout=None): 6904 ''' 6905 Lists existing workflow assignments. 6906 ''' 6907 return self.workflow_assignments.list(filter, *args, timeout=timeout) 6908 6909 6910class WorkflowAssignmentsHistory: 6911 ''' 6912 WorkflowAssignmentsHistory provides records of all changes to the state of a WorkflowAssignment. 6913 See `strongdm.models.WorkflowAssignmentHistory`. 6914 ''' 6915 def __init__(self, channel, client): 6916 self.parent = client 6917 self.stub = WorkflowAssignmentsHistoryStub(channel) 6918 6919 def list(self, filter, *args, timeout=None): 6920 ''' 6921 List gets a list of WorkflowAssignmentsHistory records matching a given set of criteria. 6922 ''' 6923 deadline = None if timeout is None else time.time() + timeout 6924 req = WorkflowAssignmentsHistoryListRequest() 6925 req.meta.CopyFrom(ListRequestMetadata()) 6926 if self.parent.page_limit > 0: 6927 req.meta.limit = self.parent.page_limit 6928 if self.parent.snapshot_datetime is not None: 6929 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6930 6931 req.filter = plumbing.quote_filter_args(filter, *args) 6932 6933 def generator(svc, req): 6934 tries = 0 6935 while True: 6936 t = None if deadline is None else deadline - time.time() 6937 try: 6938 plumbing_response = svc.stub.List( 6939 req, 6940 metadata=svc.parent.get_metadata( 6941 'WorkflowAssignmentsHistory.List', req), 6942 timeout=t) 6943 except Exception as e: 6944 if self.parent.shouldRetry(tries, e, deadline): 6945 tries += 1 6946 time.sleep( 6947 self.parent.exponentialBackoff(tries, deadline)) 6948 continue 6949 raise plumbing.convert_error_to_porcelain(e) from e 6950 tries = 0 6951 for plumbing_item in plumbing_response.history: 6952 yield plumbing.convert_workflow_assignment_history_to_porcelain( 6953 plumbing_item) 6954 if plumbing_response.meta.next_cursor == '': 6955 break 6956 req.meta.cursor = plumbing_response.meta.next_cursor 6957 6958 return generator(self, req) 6959 6960 6961class WorkflowRoles: 6962 ''' 6963 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6964 to request access to a resource via the workflow. 6965 See `strongdm.models.WorkflowRole`. 6966 ''' 6967 def __init__(self, channel, client): 6968 self.parent = client 6969 self.stub = WorkflowRolesStub(channel) 6970 6971 def create(self, workflow_role, timeout=None): 6972 ''' 6973 Create creates a new workflow role 6974 ''' 6975 deadline = None if timeout is None else time.time() + timeout 6976 req = WorkflowRolesCreateRequest() 6977 6978 if workflow_role is not None: 6979 req.workflow_role.CopyFrom( 6980 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6981 tries = 0 6982 plumbing_response = None 6983 while True: 6984 t = None if deadline is None else deadline - time.time() 6985 try: 6986 plumbing_response = self.stub.Create( 6987 req, 6988 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6989 req), 6990 timeout=t) 6991 except Exception as e: 6992 if self.parent.shouldRetry(tries, e, deadline): 6993 tries += 1 6994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6995 continue 6996 raise plumbing.convert_error_to_porcelain(e) from e 6997 break 6998 6999 resp = models.WorkflowRolesCreateResponse() 7000 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7001 plumbing_response.rate_limit) 7002 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7003 plumbing_response.workflow_role) 7004 return resp 7005 7006 def get(self, id, timeout=None): 7007 ''' 7008 Get reads one workflow role by ID. 7009 ''' 7010 deadline = None if timeout is None else time.time() + timeout 7011 req = WorkflowRoleGetRequest() 7012 if self.parent.snapshot_datetime is not None: 7013 req.meta.CopyFrom(GetRequestMetadata()) 7014 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7015 7016 req.id = (id) 7017 tries = 0 7018 plumbing_response = None 7019 while True: 7020 t = None if deadline is None else deadline - time.time() 7021 try: 7022 plumbing_response = self.stub.Get( 7023 req, 7024 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7025 req), 7026 timeout=t) 7027 except Exception as e: 7028 if self.parent.shouldRetry(tries, e, deadline): 7029 tries += 1 7030 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7031 continue 7032 raise plumbing.convert_error_to_porcelain(e) from e 7033 break 7034 7035 resp = models.WorkflowRoleGetResponse() 7036 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7037 plumbing_response.meta) 7038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7039 plumbing_response.rate_limit) 7040 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7041 plumbing_response.workflow_role) 7042 return resp 7043 7044 def delete(self, id, timeout=None): 7045 ''' 7046 Delete deletes a workflow role 7047 ''' 7048 deadline = None if timeout is None else time.time() + timeout 7049 req = WorkflowRolesDeleteRequest() 7050 7051 req.id = (id) 7052 tries = 0 7053 plumbing_response = None 7054 while True: 7055 t = None if deadline is None else deadline - time.time() 7056 try: 7057 plumbing_response = self.stub.Delete( 7058 req, 7059 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7060 req), 7061 timeout=t) 7062 except Exception as e: 7063 if self.parent.shouldRetry(tries, e, deadline): 7064 tries += 1 7065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7066 continue 7067 raise plumbing.convert_error_to_porcelain(e) from e 7068 break 7069 7070 resp = models.WorkflowRolesDeleteResponse() 7071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7072 plumbing_response.rate_limit) 7073 return resp 7074 7075 def list(self, filter, *args, timeout=None): 7076 ''' 7077 Lists existing workflow roles. 7078 ''' 7079 deadline = None if timeout is None else time.time() + timeout 7080 req = WorkflowRolesListRequest() 7081 req.meta.CopyFrom(ListRequestMetadata()) 7082 if self.parent.page_limit > 0: 7083 req.meta.limit = self.parent.page_limit 7084 if self.parent.snapshot_datetime is not None: 7085 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7086 7087 req.filter = plumbing.quote_filter_args(filter, *args) 7088 7089 def generator(svc, req): 7090 tries = 0 7091 while True: 7092 t = None if deadline is None else deadline - time.time() 7093 try: 7094 plumbing_response = svc.stub.List( 7095 req, 7096 metadata=svc.parent.get_metadata( 7097 'WorkflowRoles.List', req), 7098 timeout=t) 7099 except Exception as e: 7100 if self.parent.shouldRetry(tries, e, deadline): 7101 tries += 1 7102 time.sleep( 7103 self.parent.exponentialBackoff(tries, deadline)) 7104 continue 7105 raise plumbing.convert_error_to_porcelain(e) from e 7106 tries = 0 7107 for plumbing_item in plumbing_response.workflow_role: 7108 yield plumbing.convert_workflow_role_to_porcelain( 7109 plumbing_item) 7110 if plumbing_response.meta.next_cursor == '': 7111 break 7112 req.meta.cursor = plumbing_response.meta.next_cursor 7113 7114 return generator(self, req) 7115 7116 7117class SnapshotWorkflowRoles: 7118 ''' 7119 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7120 service for historical queries. 7121 ''' 7122 def __init__(self, workflow_roles): 7123 self.workflow_roles = workflow_roles 7124 7125 def get(self, id, timeout=None): 7126 ''' 7127 Get reads one workflow role by ID. 7128 ''' 7129 return self.workflow_roles.get(id, timeout=timeout) 7130 7131 def list(self, filter, *args, timeout=None): 7132 ''' 7133 Lists existing workflow roles. 7134 ''' 7135 return self.workflow_roles.list(filter, *args, timeout=timeout) 7136 7137 7138class WorkflowRolesHistory: 7139 ''' 7140 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7141 See `strongdm.models.WorkflowRoleHistory`. 7142 ''' 7143 def __init__(self, channel, client): 7144 self.parent = client 7145 self.stub = WorkflowRolesHistoryStub(channel) 7146 7147 def list(self, filter, *args, timeout=None): 7148 ''' 7149 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7150 ''' 7151 deadline = None if timeout is None else time.time() + timeout 7152 req = WorkflowRolesHistoryListRequest() 7153 req.meta.CopyFrom(ListRequestMetadata()) 7154 if self.parent.page_limit > 0: 7155 req.meta.limit = self.parent.page_limit 7156 if self.parent.snapshot_datetime is not None: 7157 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7158 7159 req.filter = plumbing.quote_filter_args(filter, *args) 7160 7161 def generator(svc, req): 7162 tries = 0 7163 while True: 7164 t = None if deadline is None else deadline - time.time() 7165 try: 7166 plumbing_response = svc.stub.List( 7167 req, 7168 metadata=svc.parent.get_metadata( 7169 'WorkflowRolesHistory.List', req), 7170 timeout=t) 7171 except Exception as e: 7172 if self.parent.shouldRetry(tries, e, deadline): 7173 tries += 1 7174 time.sleep( 7175 self.parent.exponentialBackoff(tries, deadline)) 7176 continue 7177 raise plumbing.convert_error_to_porcelain(e) from e 7178 tries = 0 7179 for plumbing_item in plumbing_response.history: 7180 yield plumbing.convert_workflow_role_history_to_porcelain( 7181 plumbing_item) 7182 if plumbing_response.meta.next_cursor == '': 7183 break 7184 req.meta.cursor = plumbing_response.meta.next_cursor 7185 7186 return generator(self, req) 7187 7188 7189class Workflows: 7190 ''' 7191 Workflows are the collection of rules that define the resources to which access can be requested, 7192 the users that can request that access, and the mechanism for approving those requests which can either 7193 be automatic approval or a set of users authorized to approve the requests. 7194 See `strongdm.models.Workflow`. 7195 ''' 7196 def __init__(self, channel, client): 7197 self.parent = client 7198 self.stub = WorkflowsStub(channel) 7199 7200 def create(self, workflow, timeout=None): 7201 ''' 7202 Create creates a new workflow and requires a name for the workflow. 7203 ''' 7204 deadline = None if timeout is None else time.time() + timeout 7205 req = WorkflowCreateRequest() 7206 7207 if workflow is not None: 7208 req.workflow.CopyFrom( 7209 plumbing.convert_workflow_to_plumbing(workflow)) 7210 tries = 0 7211 plumbing_response = None 7212 while True: 7213 t = None if deadline is None else deadline - time.time() 7214 try: 7215 plumbing_response = self.stub.Create( 7216 req, 7217 metadata=self.parent.get_metadata('Workflows.Create', req), 7218 timeout=t) 7219 except Exception as e: 7220 if self.parent.shouldRetry(tries, e, deadline): 7221 tries += 1 7222 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7223 continue 7224 raise plumbing.convert_error_to_porcelain(e) from e 7225 break 7226 7227 resp = models.WorkflowCreateResponse() 7228 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7229 plumbing_response.rate_limit) 7230 resp.workflow = plumbing.convert_workflow_to_porcelain( 7231 plumbing_response.workflow) 7232 return resp 7233 7234 def get(self, id, timeout=None): 7235 ''' 7236 Get reads one workflow by ID. 7237 ''' 7238 deadline = None if timeout is None else time.time() + timeout 7239 req = WorkflowGetRequest() 7240 if self.parent.snapshot_datetime is not None: 7241 req.meta.CopyFrom(GetRequestMetadata()) 7242 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7243 7244 req.id = (id) 7245 tries = 0 7246 plumbing_response = None 7247 while True: 7248 t = None if deadline is None else deadline - time.time() 7249 try: 7250 plumbing_response = self.stub.Get( 7251 req, 7252 metadata=self.parent.get_metadata('Workflows.Get', req), 7253 timeout=t) 7254 except Exception as e: 7255 if self.parent.shouldRetry(tries, e, deadline): 7256 tries += 1 7257 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7258 continue 7259 raise plumbing.convert_error_to_porcelain(e) from e 7260 break 7261 7262 resp = models.WorkflowGetResponse() 7263 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7264 plumbing_response.meta) 7265 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7266 plumbing_response.rate_limit) 7267 resp.workflow = plumbing.convert_workflow_to_porcelain( 7268 plumbing_response.workflow) 7269 return resp 7270 7271 def delete(self, id, timeout=None): 7272 ''' 7273 Delete deletes an existing workflow. 7274 ''' 7275 deadline = None if timeout is None else time.time() + timeout 7276 req = WorkflowDeleteRequest() 7277 7278 req.id = (id) 7279 tries = 0 7280 plumbing_response = None 7281 while True: 7282 t = None if deadline is None else deadline - time.time() 7283 try: 7284 plumbing_response = self.stub.Delete( 7285 req, 7286 metadata=self.parent.get_metadata('Workflows.Delete', req), 7287 timeout=t) 7288 except Exception as e: 7289 if self.parent.shouldRetry(tries, e, deadline): 7290 tries += 1 7291 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7292 continue 7293 raise plumbing.convert_error_to_porcelain(e) from e 7294 break 7295 7296 resp = models.WorkflowDeleteResponse() 7297 resp.id = (plumbing_response.id) 7298 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7299 plumbing_response.rate_limit) 7300 return resp 7301 7302 def update(self, workflow, timeout=None): 7303 ''' 7304 Update updates an existing workflow. 7305 ''' 7306 deadline = None if timeout is None else time.time() + timeout 7307 req = WorkflowUpdateRequest() 7308 7309 if workflow is not None: 7310 req.workflow.CopyFrom( 7311 plumbing.convert_workflow_to_plumbing(workflow)) 7312 tries = 0 7313 plumbing_response = None 7314 while True: 7315 t = None if deadline is None else deadline - time.time() 7316 try: 7317 plumbing_response = self.stub.Update( 7318 req, 7319 metadata=self.parent.get_metadata('Workflows.Update', req), 7320 timeout=t) 7321 except Exception as e: 7322 if self.parent.shouldRetry(tries, e, deadline): 7323 tries += 1 7324 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7325 continue 7326 raise plumbing.convert_error_to_porcelain(e) from e 7327 break 7328 7329 resp = models.WorkflowUpdateResponse() 7330 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7331 plumbing_response.rate_limit) 7332 resp.workflow = plumbing.convert_workflow_to_porcelain( 7333 plumbing_response.workflow) 7334 return resp 7335 7336 def list(self, filter, *args, timeout=None): 7337 ''' 7338 Lists existing workflows. 7339 ''' 7340 deadline = None if timeout is None else time.time() + timeout 7341 req = WorkflowListRequest() 7342 req.meta.CopyFrom(ListRequestMetadata()) 7343 if self.parent.page_limit > 0: 7344 req.meta.limit = self.parent.page_limit 7345 if self.parent.snapshot_datetime is not None: 7346 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7347 7348 req.filter = plumbing.quote_filter_args(filter, *args) 7349 7350 def generator(svc, req): 7351 tries = 0 7352 while True: 7353 t = None if deadline is None else deadline - time.time() 7354 try: 7355 plumbing_response = svc.stub.List( 7356 req, 7357 metadata=svc.parent.get_metadata( 7358 'Workflows.List', req), 7359 timeout=t) 7360 except Exception as e: 7361 if self.parent.shouldRetry(tries, e, deadline): 7362 tries += 1 7363 time.sleep( 7364 self.parent.exponentialBackoff(tries, deadline)) 7365 continue 7366 raise plumbing.convert_error_to_porcelain(e) from e 7367 tries = 0 7368 for plumbing_item in plumbing_response.workflows: 7369 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7370 if plumbing_response.meta.next_cursor == '': 7371 break 7372 req.meta.cursor = plumbing_response.meta.next_cursor 7373 7374 return generator(self, req) 7375 7376 7377class SnapshotWorkflows: 7378 ''' 7379 SnapshotWorkflows exposes the read only methods of the Workflows 7380 service for historical queries. 7381 ''' 7382 def __init__(self, workflows): 7383 self.workflows = workflows 7384 7385 def get(self, id, timeout=None): 7386 ''' 7387 Get reads one workflow by ID. 7388 ''' 7389 return self.workflows.get(id, timeout=timeout) 7390 7391 def list(self, filter, *args, timeout=None): 7392 ''' 7393 Lists existing workflows. 7394 ''' 7395 return self.workflows.list(filter, *args, timeout=timeout) 7396 7397 7398class WorkflowsHistory: 7399 ''' 7400 WorkflowsHistory provides records of all changes to the state of a Workflow. 7401 See `strongdm.models.WorkflowHistory`. 7402 ''' 7403 def __init__(self, channel, client): 7404 self.parent = client 7405 self.stub = WorkflowsHistoryStub(channel) 7406 7407 def list(self, filter, *args, timeout=None): 7408 ''' 7409 List gets a list of WorkflowHistory records matching a given set of criteria. 7410 ''' 7411 deadline = None if timeout is None else time.time() + timeout 7412 req = WorkflowHistoryListRequest() 7413 req.meta.CopyFrom(ListRequestMetadata()) 7414 if self.parent.page_limit > 0: 7415 req.meta.limit = self.parent.page_limit 7416 if self.parent.snapshot_datetime is not None: 7417 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7418 7419 req.filter = plumbing.quote_filter_args(filter, *args) 7420 7421 def generator(svc, req): 7422 tries = 0 7423 while True: 7424 t = None if deadline is None else deadline - time.time() 7425 try: 7426 plumbing_response = svc.stub.List( 7427 req, 7428 metadata=svc.parent.get_metadata( 7429 'WorkflowsHistory.List', req), 7430 timeout=t) 7431 except Exception as e: 7432 if self.parent.shouldRetry(tries, e, deadline): 7433 tries += 1 7434 time.sleep( 7435 self.parent.exponentialBackoff(tries, deadline)) 7436 continue 7437 raise plumbing.convert_error_to_porcelain(e) from e 7438 tries = 0 7439 for plumbing_item in plumbing_response.history: 7440 yield plumbing.convert_workflow_history_to_porcelain( 7441 plumbing_item) 7442 if plumbing_response.meta.next_cursor == '': 7443 break 7444 req.meta.cursor = plumbing_response.meta.next_cursor 7445 7446 return generator(self, req)
def
deprecated(func)
161def deprecated(func): 162 """This is a decorator which can be used to mark functions 163 as deprecated. It will result in a warning being emitted 164 when the function is used.""" 165 @functools.wraps(func) 166 def new_func(*args, **kwargs): 167 warnings.warn("Call to deprecated function {}.".format(func.__name__), 168 category=DeprecationWarning, 169 stacklevel=2) 170 return func(*args, **kwargs) 171 172 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:
175class AccessRequests: 176 ''' 177 AccessRequests are requests for access to a resource that may match a Workflow. 178 See `strongdm.models.AccessRequest`. 179 ''' 180 def __init__(self, channel, client): 181 self.parent = client 182 self.stub = AccessRequestsStub(channel) 183 184 def list(self, filter, *args, timeout=None): 185 ''' 186 Lists existing access requests. 187 ''' 188 deadline = None if timeout is None else time.time() + timeout 189 req = AccessRequestListRequest() 190 req.meta.CopyFrom(ListRequestMetadata()) 191 if self.parent.page_limit > 0: 192 req.meta.limit = self.parent.page_limit 193 if self.parent.snapshot_datetime is not None: 194 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 195 196 req.filter = plumbing.quote_filter_args(filter, *args) 197 198 def generator(svc, req): 199 tries = 0 200 while True: 201 t = None if deadline is None else deadline - time.time() 202 try: 203 plumbing_response = svc.stub.List( 204 req, 205 metadata=svc.parent.get_metadata( 206 'AccessRequests.List', req), 207 timeout=t) 208 except Exception as e: 209 if self.parent.shouldRetry(tries, e, deadline): 210 tries += 1 211 time.sleep( 212 self.parent.exponentialBackoff(tries, deadline)) 213 continue 214 raise plumbing.convert_error_to_porcelain(e) from e 215 tries = 0 216 for plumbing_item in plumbing_response.access_requests: 217 yield plumbing.convert_access_request_to_porcelain( 218 plumbing_item) 219 if plumbing_response.meta.next_cursor == '': 220 break 221 req.meta.cursor = plumbing_response.meta.next_cursor 222 223 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)
184 def list(self, filter, *args, timeout=None): 185 ''' 186 Lists existing access requests. 187 ''' 188 deadline = None if timeout is None else time.time() + timeout 189 req = AccessRequestListRequest() 190 req.meta.CopyFrom(ListRequestMetadata()) 191 if self.parent.page_limit > 0: 192 req.meta.limit = self.parent.page_limit 193 if self.parent.snapshot_datetime is not None: 194 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 195 196 req.filter = plumbing.quote_filter_args(filter, *args) 197 198 def generator(svc, req): 199 tries = 0 200 while True: 201 t = None if deadline is None else deadline - time.time() 202 try: 203 plumbing_response = svc.stub.List( 204 req, 205 metadata=svc.parent.get_metadata( 206 'AccessRequests.List', req), 207 timeout=t) 208 except Exception as e: 209 if self.parent.shouldRetry(tries, e, deadline): 210 tries += 1 211 time.sleep( 212 self.parent.exponentialBackoff(tries, deadline)) 213 continue 214 raise plumbing.convert_error_to_porcelain(e) from e 215 tries = 0 216 for plumbing_item in plumbing_response.access_requests: 217 yield plumbing.convert_access_request_to_porcelain( 218 plumbing_item) 219 if plumbing_response.meta.next_cursor == '': 220 break 221 req.meta.cursor = plumbing_response.meta.next_cursor 222 223 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
226class SnapshotAccessRequests: 227 ''' 228 SnapshotAccessRequests exposes the read only methods of the AccessRequests 229 service for historical queries. 230 ''' 231 def __init__(self, access_requests): 232 self.access_requests = access_requests 233 234 def list(self, filter, *args, timeout=None): 235 ''' 236 Lists existing access requests. 237 ''' 238 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
241class AccessRequestEventsHistory: 242 ''' 243 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 244 See `strongdm.models.AccessRequestEventHistory`. 245 ''' 246 def __init__(self, channel, client): 247 self.parent = client 248 self.stub = AccessRequestEventsHistoryStub(channel) 249 250 def list(self, filter, *args, timeout=None): 251 ''' 252 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 253 ''' 254 deadline = None if timeout is None else time.time() + timeout 255 req = AccessRequestEventHistoryListRequest() 256 req.meta.CopyFrom(ListRequestMetadata()) 257 if self.parent.page_limit > 0: 258 req.meta.limit = self.parent.page_limit 259 if self.parent.snapshot_datetime is not None: 260 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 261 262 req.filter = plumbing.quote_filter_args(filter, *args) 263 264 def generator(svc, req): 265 tries = 0 266 while True: 267 t = None if deadline is None else deadline - time.time() 268 try: 269 plumbing_response = svc.stub.List( 270 req, 271 metadata=svc.parent.get_metadata( 272 'AccessRequestEventsHistory.List', req), 273 timeout=t) 274 except Exception as e: 275 if self.parent.shouldRetry(tries, e, deadline): 276 tries += 1 277 time.sleep( 278 self.parent.exponentialBackoff(tries, deadline)) 279 continue 280 raise plumbing.convert_error_to_porcelain(e) from e 281 tries = 0 282 for plumbing_item in plumbing_response.history: 283 yield plumbing.convert_access_request_event_history_to_porcelain( 284 plumbing_item) 285 if plumbing_response.meta.next_cursor == '': 286 break 287 req.meta.cursor = plumbing_response.meta.next_cursor 288 289 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)
250 def list(self, filter, *args, timeout=None): 251 ''' 252 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 253 ''' 254 deadline = None if timeout is None else time.time() + timeout 255 req = AccessRequestEventHistoryListRequest() 256 req.meta.CopyFrom(ListRequestMetadata()) 257 if self.parent.page_limit > 0: 258 req.meta.limit = self.parent.page_limit 259 if self.parent.snapshot_datetime is not None: 260 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 261 262 req.filter = plumbing.quote_filter_args(filter, *args) 263 264 def generator(svc, req): 265 tries = 0 266 while True: 267 t = None if deadline is None else deadline - time.time() 268 try: 269 plumbing_response = svc.stub.List( 270 req, 271 metadata=svc.parent.get_metadata( 272 'AccessRequestEventsHistory.List', req), 273 timeout=t) 274 except Exception as e: 275 if self.parent.shouldRetry(tries, e, deadline): 276 tries += 1 277 time.sleep( 278 self.parent.exponentialBackoff(tries, deadline)) 279 continue 280 raise plumbing.convert_error_to_porcelain(e) from e 281 tries = 0 282 for plumbing_item in plumbing_response.history: 283 yield plumbing.convert_access_request_event_history_to_porcelain( 284 plumbing_item) 285 if plumbing_response.meta.next_cursor == '': 286 break 287 req.meta.cursor = plumbing_response.meta.next_cursor 288 289 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
292class AccessRequestsHistory: 293 ''' 294 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 295 See `strongdm.models.AccessRequestHistory`. 296 ''' 297 def __init__(self, channel, client): 298 self.parent = client 299 self.stub = AccessRequestsHistoryStub(channel) 300 301 def list(self, filter, *args, timeout=None): 302 ''' 303 List gets a list of AccessRequestHistory records matching a given set of criteria. 304 ''' 305 deadline = None if timeout is None else time.time() + timeout 306 req = AccessRequestHistoryListRequest() 307 req.meta.CopyFrom(ListRequestMetadata()) 308 if self.parent.page_limit > 0: 309 req.meta.limit = self.parent.page_limit 310 if self.parent.snapshot_datetime is not None: 311 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 312 313 req.filter = plumbing.quote_filter_args(filter, *args) 314 315 def generator(svc, req): 316 tries = 0 317 while True: 318 t = None if deadline is None else deadline - time.time() 319 try: 320 plumbing_response = svc.stub.List( 321 req, 322 metadata=svc.parent.get_metadata( 323 'AccessRequestsHistory.List', req), 324 timeout=t) 325 except Exception as e: 326 if self.parent.shouldRetry(tries, e, deadline): 327 tries += 1 328 time.sleep( 329 self.parent.exponentialBackoff(tries, deadline)) 330 continue 331 raise plumbing.convert_error_to_porcelain(e) from e 332 tries = 0 333 for plumbing_item in plumbing_response.history: 334 yield plumbing.convert_access_request_history_to_porcelain( 335 plumbing_item) 336 if plumbing_response.meta.next_cursor == '': 337 break 338 req.meta.cursor = plumbing_response.meta.next_cursor 339 340 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)
301 def list(self, filter, *args, timeout=None): 302 ''' 303 List gets a list of AccessRequestHistory records matching a given set of criteria. 304 ''' 305 deadline = None if timeout is None else time.time() + timeout 306 req = AccessRequestHistoryListRequest() 307 req.meta.CopyFrom(ListRequestMetadata()) 308 if self.parent.page_limit > 0: 309 req.meta.limit = self.parent.page_limit 310 if self.parent.snapshot_datetime is not None: 311 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 312 313 req.filter = plumbing.quote_filter_args(filter, *args) 314 315 def generator(svc, req): 316 tries = 0 317 while True: 318 t = None if deadline is None else deadline - time.time() 319 try: 320 plumbing_response = svc.stub.List( 321 req, 322 metadata=svc.parent.get_metadata( 323 'AccessRequestsHistory.List', req), 324 timeout=t) 325 except Exception as e: 326 if self.parent.shouldRetry(tries, e, deadline): 327 tries += 1 328 time.sleep( 329 self.parent.exponentialBackoff(tries, deadline)) 330 continue 331 raise plumbing.convert_error_to_porcelain(e) from e 332 tries = 0 333 for plumbing_item in plumbing_response.history: 334 yield plumbing.convert_access_request_history_to_porcelain( 335 plumbing_item) 336 if plumbing_response.meta.next_cursor == '': 337 break 338 req.meta.cursor = plumbing_response.meta.next_cursor 339 340 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
343class AccountAttachments: 344 ''' 345 AccountAttachments assign an account to a role. 346 See `strongdm.models.AccountAttachment`. 347 ''' 348 def __init__(self, channel, client): 349 self.parent = client 350 self.stub = AccountAttachmentsStub(channel) 351 352 def create(self, account_attachment, timeout=None): 353 ''' 354 Create registers a new AccountAttachment. 355 ''' 356 deadline = None if timeout is None else time.time() + timeout 357 req = AccountAttachmentCreateRequest() 358 359 if account_attachment is not None: 360 req.account_attachment.CopyFrom( 361 plumbing.convert_account_attachment_to_plumbing( 362 account_attachment)) 363 tries = 0 364 plumbing_response = None 365 while True: 366 t = None if deadline is None else deadline - time.time() 367 try: 368 plumbing_response = self.stub.Create( 369 req, 370 metadata=self.parent.get_metadata( 371 'AccountAttachments.Create', req), 372 timeout=t) 373 except Exception as e: 374 if self.parent.shouldRetry(tries, e, deadline): 375 tries += 1 376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 377 continue 378 raise plumbing.convert_error_to_porcelain(e) from e 379 break 380 381 resp = models.AccountAttachmentCreateResponse() 382 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 383 plumbing_response.account_attachment) 384 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 385 plumbing_response.meta) 386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 387 plumbing_response.rate_limit) 388 return resp 389 390 def get(self, id, timeout=None): 391 ''' 392 Get reads one AccountAttachment by ID. 393 ''' 394 deadline = None if timeout is None else time.time() + timeout 395 req = AccountAttachmentGetRequest() 396 if self.parent.snapshot_datetime is not None: 397 req.meta.CopyFrom(GetRequestMetadata()) 398 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 399 400 req.id = (id) 401 tries = 0 402 plumbing_response = None 403 while True: 404 t = None if deadline is None else deadline - time.time() 405 try: 406 plumbing_response = self.stub.Get( 407 req, 408 metadata=self.parent.get_metadata('AccountAttachments.Get', 409 req), 410 timeout=t) 411 except Exception as e: 412 if self.parent.shouldRetry(tries, e, deadline): 413 tries += 1 414 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 415 continue 416 raise plumbing.convert_error_to_porcelain(e) from e 417 break 418 419 resp = models.AccountAttachmentGetResponse() 420 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 421 plumbing_response.account_attachment) 422 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 423 plumbing_response.meta) 424 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 425 plumbing_response.rate_limit) 426 return resp 427 428 def delete(self, id, timeout=None): 429 ''' 430 Delete removes a AccountAttachment by ID. 431 ''' 432 deadline = None if timeout is None else time.time() + timeout 433 req = AccountAttachmentDeleteRequest() 434 435 req.id = (id) 436 tries = 0 437 plumbing_response = None 438 while True: 439 t = None if deadline is None else deadline - time.time() 440 try: 441 plumbing_response = self.stub.Delete( 442 req, 443 metadata=self.parent.get_metadata( 444 'AccountAttachments.Delete', req), 445 timeout=t) 446 except Exception as e: 447 if self.parent.shouldRetry(tries, e, deadline): 448 tries += 1 449 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 450 continue 451 raise plumbing.convert_error_to_porcelain(e) from e 452 break 453 454 resp = models.AccountAttachmentDeleteResponse() 455 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 456 plumbing_response.meta) 457 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 458 plumbing_response.rate_limit) 459 return resp 460 461 def list(self, filter, *args, timeout=None): 462 ''' 463 List gets a list of AccountAttachments matching a given set of criteria. 464 ''' 465 deadline = None if timeout is None else time.time() + timeout 466 req = AccountAttachmentListRequest() 467 req.meta.CopyFrom(ListRequestMetadata()) 468 if self.parent.page_limit > 0: 469 req.meta.limit = self.parent.page_limit 470 if self.parent.snapshot_datetime is not None: 471 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 472 473 req.filter = plumbing.quote_filter_args(filter, *args) 474 475 def generator(svc, req): 476 tries = 0 477 while True: 478 t = None if deadline is None else deadline - time.time() 479 try: 480 plumbing_response = svc.stub.List( 481 req, 482 metadata=svc.parent.get_metadata( 483 'AccountAttachments.List', req), 484 timeout=t) 485 except Exception as e: 486 if self.parent.shouldRetry(tries, e, deadline): 487 tries += 1 488 time.sleep( 489 self.parent.exponentialBackoff(tries, deadline)) 490 continue 491 raise plumbing.convert_error_to_porcelain(e) from e 492 tries = 0 493 for plumbing_item in plumbing_response.account_attachments: 494 yield plumbing.convert_account_attachment_to_porcelain( 495 plumbing_item) 496 if plumbing_response.meta.next_cursor == '': 497 break 498 req.meta.cursor = plumbing_response.meta.next_cursor 499 500 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
352 def create(self, account_attachment, timeout=None): 353 ''' 354 Create registers a new AccountAttachment. 355 ''' 356 deadline = None if timeout is None else time.time() + timeout 357 req = AccountAttachmentCreateRequest() 358 359 if account_attachment is not None: 360 req.account_attachment.CopyFrom( 361 plumbing.convert_account_attachment_to_plumbing( 362 account_attachment)) 363 tries = 0 364 plumbing_response = None 365 while True: 366 t = None if deadline is None else deadline - time.time() 367 try: 368 plumbing_response = self.stub.Create( 369 req, 370 metadata=self.parent.get_metadata( 371 'AccountAttachments.Create', req), 372 timeout=t) 373 except Exception as e: 374 if self.parent.shouldRetry(tries, e, deadline): 375 tries += 1 376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 377 continue 378 raise plumbing.convert_error_to_porcelain(e) from e 379 break 380 381 resp = models.AccountAttachmentCreateResponse() 382 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 383 plumbing_response.account_attachment) 384 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 385 plumbing_response.meta) 386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 387 plumbing_response.rate_limit) 388 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
390 def get(self, id, timeout=None): 391 ''' 392 Get reads one AccountAttachment by ID. 393 ''' 394 deadline = None if timeout is None else time.time() + timeout 395 req = AccountAttachmentGetRequest() 396 if self.parent.snapshot_datetime is not None: 397 req.meta.CopyFrom(GetRequestMetadata()) 398 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 399 400 req.id = (id) 401 tries = 0 402 plumbing_response = None 403 while True: 404 t = None if deadline is None else deadline - time.time() 405 try: 406 plumbing_response = self.stub.Get( 407 req, 408 metadata=self.parent.get_metadata('AccountAttachments.Get', 409 req), 410 timeout=t) 411 except Exception as e: 412 if self.parent.shouldRetry(tries, e, deadline): 413 tries += 1 414 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 415 continue 416 raise plumbing.convert_error_to_porcelain(e) from e 417 break 418 419 resp = models.AccountAttachmentGetResponse() 420 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 421 plumbing_response.account_attachment) 422 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 423 plumbing_response.meta) 424 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 425 plumbing_response.rate_limit) 426 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
428 def delete(self, id, timeout=None): 429 ''' 430 Delete removes a AccountAttachment by ID. 431 ''' 432 deadline = None if timeout is None else time.time() + timeout 433 req = AccountAttachmentDeleteRequest() 434 435 req.id = (id) 436 tries = 0 437 plumbing_response = None 438 while True: 439 t = None if deadline is None else deadline - time.time() 440 try: 441 plumbing_response = self.stub.Delete( 442 req, 443 metadata=self.parent.get_metadata( 444 'AccountAttachments.Delete', req), 445 timeout=t) 446 except Exception as e: 447 if self.parent.shouldRetry(tries, e, deadline): 448 tries += 1 449 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 450 continue 451 raise plumbing.convert_error_to_porcelain(e) from e 452 break 453 454 resp = models.AccountAttachmentDeleteResponse() 455 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 456 plumbing_response.meta) 457 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 458 plumbing_response.rate_limit) 459 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
461 def list(self, filter, *args, timeout=None): 462 ''' 463 List gets a list of AccountAttachments matching a given set of criteria. 464 ''' 465 deadline = None if timeout is None else time.time() + timeout 466 req = AccountAttachmentListRequest() 467 req.meta.CopyFrom(ListRequestMetadata()) 468 if self.parent.page_limit > 0: 469 req.meta.limit = self.parent.page_limit 470 if self.parent.snapshot_datetime is not None: 471 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 472 473 req.filter = plumbing.quote_filter_args(filter, *args) 474 475 def generator(svc, req): 476 tries = 0 477 while True: 478 t = None if deadline is None else deadline - time.time() 479 try: 480 plumbing_response = svc.stub.List( 481 req, 482 metadata=svc.parent.get_metadata( 483 'AccountAttachments.List', req), 484 timeout=t) 485 except Exception as e: 486 if self.parent.shouldRetry(tries, e, deadline): 487 tries += 1 488 time.sleep( 489 self.parent.exponentialBackoff(tries, deadline)) 490 continue 491 raise plumbing.convert_error_to_porcelain(e) from e 492 tries = 0 493 for plumbing_item in plumbing_response.account_attachments: 494 yield plumbing.convert_account_attachment_to_porcelain( 495 plumbing_item) 496 if plumbing_response.meta.next_cursor == '': 497 break 498 req.meta.cursor = plumbing_response.meta.next_cursor 499 500 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
503class SnapshotAccountAttachments: 504 ''' 505 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 506 service for historical queries. 507 ''' 508 def __init__(self, account_attachments): 509 self.account_attachments = account_attachments 510 511 def get(self, id, timeout=None): 512 ''' 513 Get reads one AccountAttachment by ID. 514 ''' 515 return self.account_attachments.get(id, timeout=timeout) 516 517 def list(self, filter, *args, timeout=None): 518 ''' 519 List gets a list of AccountAttachments matching a given set of criteria. 520 ''' 521 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)
511 def get(self, id, timeout=None): 512 ''' 513 Get reads one AccountAttachment by ID. 514 ''' 515 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
517 def list(self, filter, *args, timeout=None): 518 ''' 519 List gets a list of AccountAttachments matching a given set of criteria. 520 ''' 521 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
524class AccountAttachmentsHistory: 525 ''' 526 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 527 See `strongdm.models.AccountAttachmentHistory`. 528 ''' 529 def __init__(self, channel, client): 530 self.parent = client 531 self.stub = AccountAttachmentsHistoryStub(channel) 532 533 def list(self, filter, *args, timeout=None): 534 ''' 535 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 536 ''' 537 deadline = None if timeout is None else time.time() + timeout 538 req = AccountAttachmentHistoryListRequest() 539 req.meta.CopyFrom(ListRequestMetadata()) 540 if self.parent.page_limit > 0: 541 req.meta.limit = self.parent.page_limit 542 if self.parent.snapshot_datetime is not None: 543 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 544 545 req.filter = plumbing.quote_filter_args(filter, *args) 546 547 def generator(svc, req): 548 tries = 0 549 while True: 550 t = None if deadline is None else deadline - time.time() 551 try: 552 plumbing_response = svc.stub.List( 553 req, 554 metadata=svc.parent.get_metadata( 555 'AccountAttachmentsHistory.List', req), 556 timeout=t) 557 except Exception as e: 558 if self.parent.shouldRetry(tries, e, deadline): 559 tries += 1 560 time.sleep( 561 self.parent.exponentialBackoff(tries, deadline)) 562 continue 563 raise plumbing.convert_error_to_porcelain(e) from e 564 tries = 0 565 for plumbing_item in plumbing_response.history: 566 yield plumbing.convert_account_attachment_history_to_porcelain( 567 plumbing_item) 568 if plumbing_response.meta.next_cursor == '': 569 break 570 req.meta.cursor = plumbing_response.meta.next_cursor 571 572 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)
533 def list(self, filter, *args, timeout=None): 534 ''' 535 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 536 ''' 537 deadline = None if timeout is None else time.time() + timeout 538 req = AccountAttachmentHistoryListRequest() 539 req.meta.CopyFrom(ListRequestMetadata()) 540 if self.parent.page_limit > 0: 541 req.meta.limit = self.parent.page_limit 542 if self.parent.snapshot_datetime is not None: 543 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 544 545 req.filter = plumbing.quote_filter_args(filter, *args) 546 547 def generator(svc, req): 548 tries = 0 549 while True: 550 t = None if deadline is None else deadline - time.time() 551 try: 552 plumbing_response = svc.stub.List( 553 req, 554 metadata=svc.parent.get_metadata( 555 'AccountAttachmentsHistory.List', req), 556 timeout=t) 557 except Exception as e: 558 if self.parent.shouldRetry(tries, e, deadline): 559 tries += 1 560 time.sleep( 561 self.parent.exponentialBackoff(tries, deadline)) 562 continue 563 raise plumbing.convert_error_to_porcelain(e) from e 564 tries = 0 565 for plumbing_item in plumbing_response.history: 566 yield plumbing.convert_account_attachment_history_to_porcelain( 567 plumbing_item) 568 if plumbing_response.meta.next_cursor == '': 569 break 570 req.meta.cursor = plumbing_response.meta.next_cursor 571 572 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
575class AccountGrants: 576 ''' 577 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 578 See `strongdm.models.AccountGrant`. 579 ''' 580 def __init__(self, channel, client): 581 self.parent = client 582 self.stub = AccountGrantsStub(channel) 583 584 def create(self, account_grant, timeout=None): 585 ''' 586 Create registers a new AccountGrant. 587 ''' 588 deadline = None if timeout is None else time.time() + timeout 589 req = AccountGrantCreateRequest() 590 591 if account_grant is not None: 592 req.account_grant.CopyFrom( 593 plumbing.convert_account_grant_to_plumbing(account_grant)) 594 tries = 0 595 plumbing_response = None 596 while True: 597 t = None if deadline is None else deadline - time.time() 598 try: 599 plumbing_response = self.stub.Create( 600 req, 601 metadata=self.parent.get_metadata('AccountGrants.Create', 602 req), 603 timeout=t) 604 except Exception as e: 605 if self.parent.shouldRetry(tries, e, deadline): 606 tries += 1 607 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 608 continue 609 raise plumbing.convert_error_to_porcelain(e) from e 610 break 611 612 resp = models.AccountGrantCreateResponse() 613 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 614 plumbing_response.account_grant) 615 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 616 plumbing_response.meta) 617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 618 plumbing_response.rate_limit) 619 return resp 620 621 def get(self, id, timeout=None): 622 ''' 623 Get reads one AccountGrant by ID. 624 ''' 625 deadline = None if timeout is None else time.time() + timeout 626 req = AccountGrantGetRequest() 627 if self.parent.snapshot_datetime is not None: 628 req.meta.CopyFrom(GetRequestMetadata()) 629 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 630 631 req.id = (id) 632 tries = 0 633 plumbing_response = None 634 while True: 635 t = None if deadline is None else deadline - time.time() 636 try: 637 plumbing_response = self.stub.Get( 638 req, 639 metadata=self.parent.get_metadata('AccountGrants.Get', 640 req), 641 timeout=t) 642 except Exception as e: 643 if self.parent.shouldRetry(tries, e, deadline): 644 tries += 1 645 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 646 continue 647 raise plumbing.convert_error_to_porcelain(e) from e 648 break 649 650 resp = models.AccountGrantGetResponse() 651 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 652 plumbing_response.account_grant) 653 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 654 plumbing_response.meta) 655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 656 plumbing_response.rate_limit) 657 return resp 658 659 def delete(self, id, timeout=None): 660 ''' 661 Delete removes a AccountGrant by ID. 662 ''' 663 deadline = None if timeout is None else time.time() + timeout 664 req = AccountGrantDeleteRequest() 665 666 req.id = (id) 667 tries = 0 668 plumbing_response = None 669 while True: 670 t = None if deadline is None else deadline - time.time() 671 try: 672 plumbing_response = self.stub.Delete( 673 req, 674 metadata=self.parent.get_metadata('AccountGrants.Delete', 675 req), 676 timeout=t) 677 except Exception as e: 678 if self.parent.shouldRetry(tries, e, deadline): 679 tries += 1 680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 681 continue 682 raise plumbing.convert_error_to_porcelain(e) from e 683 break 684 685 resp = models.AccountGrantDeleteResponse() 686 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 687 plumbing_response.meta) 688 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 689 plumbing_response.rate_limit) 690 return resp 691 692 def list(self, filter, *args, timeout=None): 693 ''' 694 List gets a list of AccountGrants matching a given set of criteria. 695 ''' 696 deadline = None if timeout is None else time.time() + timeout 697 req = AccountGrantListRequest() 698 req.meta.CopyFrom(ListRequestMetadata()) 699 if self.parent.page_limit > 0: 700 req.meta.limit = self.parent.page_limit 701 if self.parent.snapshot_datetime is not None: 702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 703 704 req.filter = plumbing.quote_filter_args(filter, *args) 705 706 def generator(svc, req): 707 tries = 0 708 while True: 709 t = None if deadline is None else deadline - time.time() 710 try: 711 plumbing_response = svc.stub.List( 712 req, 713 metadata=svc.parent.get_metadata( 714 'AccountGrants.List', req), 715 timeout=t) 716 except Exception as e: 717 if self.parent.shouldRetry(tries, e, deadline): 718 tries += 1 719 time.sleep( 720 self.parent.exponentialBackoff(tries, deadline)) 721 continue 722 raise plumbing.convert_error_to_porcelain(e) from e 723 tries = 0 724 for plumbing_item in plumbing_response.account_grants: 725 yield plumbing.convert_account_grant_to_porcelain( 726 plumbing_item) 727 if plumbing_response.meta.next_cursor == '': 728 break 729 req.meta.cursor = plumbing_response.meta.next_cursor 730 731 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)
584 def create(self, account_grant, timeout=None): 585 ''' 586 Create registers a new AccountGrant. 587 ''' 588 deadline = None if timeout is None else time.time() + timeout 589 req = AccountGrantCreateRequest() 590 591 if account_grant is not None: 592 req.account_grant.CopyFrom( 593 plumbing.convert_account_grant_to_plumbing(account_grant)) 594 tries = 0 595 plumbing_response = None 596 while True: 597 t = None if deadline is None else deadline - time.time() 598 try: 599 plumbing_response = self.stub.Create( 600 req, 601 metadata=self.parent.get_metadata('AccountGrants.Create', 602 req), 603 timeout=t) 604 except Exception as e: 605 if self.parent.shouldRetry(tries, e, deadline): 606 tries += 1 607 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 608 continue 609 raise plumbing.convert_error_to_porcelain(e) from e 610 break 611 612 resp = models.AccountGrantCreateResponse() 613 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 614 plumbing_response.account_grant) 615 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 616 plumbing_response.meta) 617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 618 plumbing_response.rate_limit) 619 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
621 def get(self, id, timeout=None): 622 ''' 623 Get reads one AccountGrant by ID. 624 ''' 625 deadline = None if timeout is None else time.time() + timeout 626 req = AccountGrantGetRequest() 627 if self.parent.snapshot_datetime is not None: 628 req.meta.CopyFrom(GetRequestMetadata()) 629 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 630 631 req.id = (id) 632 tries = 0 633 plumbing_response = None 634 while True: 635 t = None if deadline is None else deadline - time.time() 636 try: 637 plumbing_response = self.stub.Get( 638 req, 639 metadata=self.parent.get_metadata('AccountGrants.Get', 640 req), 641 timeout=t) 642 except Exception as e: 643 if self.parent.shouldRetry(tries, e, deadline): 644 tries += 1 645 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 646 continue 647 raise plumbing.convert_error_to_porcelain(e) from e 648 break 649 650 resp = models.AccountGrantGetResponse() 651 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 652 plumbing_response.account_grant) 653 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 654 plumbing_response.meta) 655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 656 plumbing_response.rate_limit) 657 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
659 def delete(self, id, timeout=None): 660 ''' 661 Delete removes a AccountGrant by ID. 662 ''' 663 deadline = None if timeout is None else time.time() + timeout 664 req = AccountGrantDeleteRequest() 665 666 req.id = (id) 667 tries = 0 668 plumbing_response = None 669 while True: 670 t = None if deadline is None else deadline - time.time() 671 try: 672 plumbing_response = self.stub.Delete( 673 req, 674 metadata=self.parent.get_metadata('AccountGrants.Delete', 675 req), 676 timeout=t) 677 except Exception as e: 678 if self.parent.shouldRetry(tries, e, deadline): 679 tries += 1 680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 681 continue 682 raise plumbing.convert_error_to_porcelain(e) from e 683 break 684 685 resp = models.AccountGrantDeleteResponse() 686 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 687 plumbing_response.meta) 688 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 689 plumbing_response.rate_limit) 690 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
692 def list(self, filter, *args, timeout=None): 693 ''' 694 List gets a list of AccountGrants matching a given set of criteria. 695 ''' 696 deadline = None if timeout is None else time.time() + timeout 697 req = AccountGrantListRequest() 698 req.meta.CopyFrom(ListRequestMetadata()) 699 if self.parent.page_limit > 0: 700 req.meta.limit = self.parent.page_limit 701 if self.parent.snapshot_datetime is not None: 702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 703 704 req.filter = plumbing.quote_filter_args(filter, *args) 705 706 def generator(svc, req): 707 tries = 0 708 while True: 709 t = None if deadline is None else deadline - time.time() 710 try: 711 plumbing_response = svc.stub.List( 712 req, 713 metadata=svc.parent.get_metadata( 714 'AccountGrants.List', req), 715 timeout=t) 716 except Exception as e: 717 if self.parent.shouldRetry(tries, e, deadline): 718 tries += 1 719 time.sleep( 720 self.parent.exponentialBackoff(tries, deadline)) 721 continue 722 raise plumbing.convert_error_to_porcelain(e) from e 723 tries = 0 724 for plumbing_item in plumbing_response.account_grants: 725 yield plumbing.convert_account_grant_to_porcelain( 726 plumbing_item) 727 if plumbing_response.meta.next_cursor == '': 728 break 729 req.meta.cursor = plumbing_response.meta.next_cursor 730 731 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
734class SnapshotAccountGrants: 735 ''' 736 SnapshotAccountGrants exposes the read only methods of the AccountGrants 737 service for historical queries. 738 ''' 739 def __init__(self, account_grants): 740 self.account_grants = account_grants 741 742 def get(self, id, timeout=None): 743 ''' 744 Get reads one AccountGrant by ID. 745 ''' 746 return self.account_grants.get(id, timeout=timeout) 747 748 def list(self, filter, *args, timeout=None): 749 ''' 750 List gets a list of AccountGrants matching a given set of criteria. 751 ''' 752 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)
742 def get(self, id, timeout=None): 743 ''' 744 Get reads one AccountGrant by ID. 745 ''' 746 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
748 def list(self, filter, *args, timeout=None): 749 ''' 750 List gets a list of AccountGrants matching a given set of criteria. 751 ''' 752 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
755class AccountGrantsHistory: 756 ''' 757 AccountGrantsHistory records all changes to the state of an AccountGrant. 758 See `strongdm.models.AccountGrantHistory`. 759 ''' 760 def __init__(self, channel, client): 761 self.parent = client 762 self.stub = AccountGrantsHistoryStub(channel) 763 764 def list(self, filter, *args, timeout=None): 765 ''' 766 List gets a list of AccountGrantHistory records matching a given set of criteria. 767 ''' 768 deadline = None if timeout is None else time.time() + timeout 769 req = AccountGrantHistoryListRequest() 770 req.meta.CopyFrom(ListRequestMetadata()) 771 if self.parent.page_limit > 0: 772 req.meta.limit = self.parent.page_limit 773 if self.parent.snapshot_datetime is not None: 774 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 775 776 req.filter = plumbing.quote_filter_args(filter, *args) 777 778 def generator(svc, req): 779 tries = 0 780 while True: 781 t = None if deadline is None else deadline - time.time() 782 try: 783 plumbing_response = svc.stub.List( 784 req, 785 metadata=svc.parent.get_metadata( 786 'AccountGrantsHistory.List', req), 787 timeout=t) 788 except Exception as e: 789 if self.parent.shouldRetry(tries, e, deadline): 790 tries += 1 791 time.sleep( 792 self.parent.exponentialBackoff(tries, deadline)) 793 continue 794 raise plumbing.convert_error_to_porcelain(e) from e 795 tries = 0 796 for plumbing_item in plumbing_response.history: 797 yield plumbing.convert_account_grant_history_to_porcelain( 798 plumbing_item) 799 if plumbing_response.meta.next_cursor == '': 800 break 801 req.meta.cursor = plumbing_response.meta.next_cursor 802 803 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)
764 def list(self, filter, *args, timeout=None): 765 ''' 766 List gets a list of AccountGrantHistory records matching a given set of criteria. 767 ''' 768 deadline = None if timeout is None else time.time() + timeout 769 req = AccountGrantHistoryListRequest() 770 req.meta.CopyFrom(ListRequestMetadata()) 771 if self.parent.page_limit > 0: 772 req.meta.limit = self.parent.page_limit 773 if self.parent.snapshot_datetime is not None: 774 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 775 776 req.filter = plumbing.quote_filter_args(filter, *args) 777 778 def generator(svc, req): 779 tries = 0 780 while True: 781 t = None if deadline is None else deadline - time.time() 782 try: 783 plumbing_response = svc.stub.List( 784 req, 785 metadata=svc.parent.get_metadata( 786 'AccountGrantsHistory.List', req), 787 timeout=t) 788 except Exception as e: 789 if self.parent.shouldRetry(tries, e, deadline): 790 tries += 1 791 time.sleep( 792 self.parent.exponentialBackoff(tries, deadline)) 793 continue 794 raise plumbing.convert_error_to_porcelain(e) from e 795 tries = 0 796 for plumbing_item in plumbing_response.history: 797 yield plumbing.convert_account_grant_history_to_porcelain( 798 plumbing_item) 799 if plumbing_response.meta.next_cursor == '': 800 break 801 req.meta.cursor = plumbing_response.meta.next_cursor 802 803 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
806class AccountPermissions: 807 ''' 808 AccountPermissions records the granular permissions accounts have, allowing them to execute 809 relevant commands via StrongDM's APIs. 810 See `strongdm.models.AccountPermission`. 811 ''' 812 def __init__(self, channel, client): 813 self.parent = client 814 self.stub = AccountPermissionsStub(channel) 815 816 def list(self, filter, *args, timeout=None): 817 ''' 818 List gets a list of Permission records matching a given set of criteria. 819 ''' 820 deadline = None if timeout is None else time.time() + timeout 821 req = AccountPermissionListRequest() 822 req.meta.CopyFrom(ListRequestMetadata()) 823 if self.parent.page_limit > 0: 824 req.meta.limit = self.parent.page_limit 825 if self.parent.snapshot_datetime is not None: 826 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 827 828 req.filter = plumbing.quote_filter_args(filter, *args) 829 830 def generator(svc, req): 831 tries = 0 832 while True: 833 t = None if deadline is None else deadline - time.time() 834 try: 835 plumbing_response = svc.stub.List( 836 req, 837 metadata=svc.parent.get_metadata( 838 'AccountPermissions.List', req), 839 timeout=t) 840 except Exception as e: 841 if self.parent.shouldRetry(tries, e, deadline): 842 tries += 1 843 time.sleep( 844 self.parent.exponentialBackoff(tries, deadline)) 845 continue 846 raise plumbing.convert_error_to_porcelain(e) from e 847 tries = 0 848 for plumbing_item in plumbing_response.permissions: 849 yield plumbing.convert_account_permission_to_porcelain( 850 plumbing_item) 851 if plumbing_response.meta.next_cursor == '': 852 break 853 req.meta.cursor = plumbing_response.meta.next_cursor 854 855 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)
816 def list(self, filter, *args, timeout=None): 817 ''' 818 List gets a list of Permission records matching a given set of criteria. 819 ''' 820 deadline = None if timeout is None else time.time() + timeout 821 req = AccountPermissionListRequest() 822 req.meta.CopyFrom(ListRequestMetadata()) 823 if self.parent.page_limit > 0: 824 req.meta.limit = self.parent.page_limit 825 if self.parent.snapshot_datetime is not None: 826 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 827 828 req.filter = plumbing.quote_filter_args(filter, *args) 829 830 def generator(svc, req): 831 tries = 0 832 while True: 833 t = None if deadline is None else deadline - time.time() 834 try: 835 plumbing_response = svc.stub.List( 836 req, 837 metadata=svc.parent.get_metadata( 838 'AccountPermissions.List', req), 839 timeout=t) 840 except Exception as e: 841 if self.parent.shouldRetry(tries, e, deadline): 842 tries += 1 843 time.sleep( 844 self.parent.exponentialBackoff(tries, deadline)) 845 continue 846 raise plumbing.convert_error_to_porcelain(e) from e 847 tries = 0 848 for plumbing_item in plumbing_response.permissions: 849 yield plumbing.convert_account_permission_to_porcelain( 850 plumbing_item) 851 if plumbing_response.meta.next_cursor == '': 852 break 853 req.meta.cursor = plumbing_response.meta.next_cursor 854 855 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
858class SnapshotAccountPermissions: 859 ''' 860 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 861 service for historical queries. 862 ''' 863 def __init__(self, account_permissions): 864 self.account_permissions = account_permissions 865 866 def list(self, filter, *args, timeout=None): 867 ''' 868 List gets a list of Permission records matching a given set of criteria. 869 ''' 870 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)
866 def list(self, filter, *args, timeout=None): 867 ''' 868 List gets a list of Permission records matching a given set of criteria. 869 ''' 870 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
873class AccountResources: 874 ''' 875 AccountResources enumerates the resources to which accounts have access. 876 The AccountResources service is read-only. 877 See `strongdm.models.AccountResource`. 878 ''' 879 def __init__(self, channel, client): 880 self.parent = client 881 self.stub = AccountResourcesStub(channel) 882 883 def list(self, filter, *args, timeout=None): 884 ''' 885 List gets a list of AccountResource records matching a given set of criteria. 886 ''' 887 deadline = None if timeout is None else time.time() + timeout 888 req = AccountResourceListRequest() 889 req.meta.CopyFrom(ListRequestMetadata()) 890 if self.parent.page_limit > 0: 891 req.meta.limit = self.parent.page_limit 892 if self.parent.snapshot_datetime is not None: 893 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 894 895 req.filter = plumbing.quote_filter_args(filter, *args) 896 897 def generator(svc, req): 898 tries = 0 899 while True: 900 t = None if deadline is None else deadline - time.time() 901 try: 902 plumbing_response = svc.stub.List( 903 req, 904 metadata=svc.parent.get_metadata( 905 'AccountResources.List', req), 906 timeout=t) 907 except Exception as e: 908 if self.parent.shouldRetry(tries, e, deadline): 909 tries += 1 910 time.sleep( 911 self.parent.exponentialBackoff(tries, deadline)) 912 continue 913 raise plumbing.convert_error_to_porcelain(e) from e 914 tries = 0 915 for plumbing_item in plumbing_response.account_resources: 916 yield plumbing.convert_account_resource_to_porcelain( 917 plumbing_item) 918 if plumbing_response.meta.next_cursor == '': 919 break 920 req.meta.cursor = plumbing_response.meta.next_cursor 921 922 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)
883 def list(self, filter, *args, timeout=None): 884 ''' 885 List gets a list of AccountResource records matching a given set of criteria. 886 ''' 887 deadline = None if timeout is None else time.time() + timeout 888 req = AccountResourceListRequest() 889 req.meta.CopyFrom(ListRequestMetadata()) 890 if self.parent.page_limit > 0: 891 req.meta.limit = self.parent.page_limit 892 if self.parent.snapshot_datetime is not None: 893 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 894 895 req.filter = plumbing.quote_filter_args(filter, *args) 896 897 def generator(svc, req): 898 tries = 0 899 while True: 900 t = None if deadline is None else deadline - time.time() 901 try: 902 plumbing_response = svc.stub.List( 903 req, 904 metadata=svc.parent.get_metadata( 905 'AccountResources.List', req), 906 timeout=t) 907 except Exception as e: 908 if self.parent.shouldRetry(tries, e, deadline): 909 tries += 1 910 time.sleep( 911 self.parent.exponentialBackoff(tries, deadline)) 912 continue 913 raise plumbing.convert_error_to_porcelain(e) from e 914 tries = 0 915 for plumbing_item in plumbing_response.account_resources: 916 yield plumbing.convert_account_resource_to_porcelain( 917 plumbing_item) 918 if plumbing_response.meta.next_cursor == '': 919 break 920 req.meta.cursor = plumbing_response.meta.next_cursor 921 922 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
925class SnapshotAccountResources: 926 ''' 927 SnapshotAccountResources exposes the read only methods of the AccountResources 928 service for historical queries. 929 ''' 930 def __init__(self, account_resources): 931 self.account_resources = account_resources 932 933 def list(self, filter, *args, timeout=None): 934 ''' 935 List gets a list of AccountResource records matching a given set of criteria. 936 ''' 937 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)
933 def list(self, filter, *args, timeout=None): 934 ''' 935 List gets a list of AccountResource records matching a given set of criteria. 936 ''' 937 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
940class AccountResourcesHistory: 941 ''' 942 AccountResourcesHistory records all changes to the state of a AccountResource. 943 See `strongdm.models.AccountResourceHistory`. 944 ''' 945 def __init__(self, channel, client): 946 self.parent = client 947 self.stub = AccountResourcesHistoryStub(channel) 948 949 def list(self, filter, *args, timeout=None): 950 ''' 951 List gets a list of AccountResourceHistory records matching a given set of criteria. 952 ''' 953 deadline = None if timeout is None else time.time() + timeout 954 req = AccountResourceHistoryListRequest() 955 req.meta.CopyFrom(ListRequestMetadata()) 956 if self.parent.page_limit > 0: 957 req.meta.limit = self.parent.page_limit 958 if self.parent.snapshot_datetime is not None: 959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 960 961 req.filter = plumbing.quote_filter_args(filter, *args) 962 963 def generator(svc, req): 964 tries = 0 965 while True: 966 t = None if deadline is None else deadline - time.time() 967 try: 968 plumbing_response = svc.stub.List( 969 req, 970 metadata=svc.parent.get_metadata( 971 'AccountResourcesHistory.List', req), 972 timeout=t) 973 except Exception as e: 974 if self.parent.shouldRetry(tries, e, deadline): 975 tries += 1 976 time.sleep( 977 self.parent.exponentialBackoff(tries, deadline)) 978 continue 979 raise plumbing.convert_error_to_porcelain(e) from e 980 tries = 0 981 for plumbing_item in plumbing_response.history: 982 yield plumbing.convert_account_resource_history_to_porcelain( 983 plumbing_item) 984 if plumbing_response.meta.next_cursor == '': 985 break 986 req.meta.cursor = plumbing_response.meta.next_cursor 987 988 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)
949 def list(self, filter, *args, timeout=None): 950 ''' 951 List gets a list of AccountResourceHistory records matching a given set of criteria. 952 ''' 953 deadline = None if timeout is None else time.time() + timeout 954 req = AccountResourceHistoryListRequest() 955 req.meta.CopyFrom(ListRequestMetadata()) 956 if self.parent.page_limit > 0: 957 req.meta.limit = self.parent.page_limit 958 if self.parent.snapshot_datetime is not None: 959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 960 961 req.filter = plumbing.quote_filter_args(filter, *args) 962 963 def generator(svc, req): 964 tries = 0 965 while True: 966 t = None if deadline is None else deadline - time.time() 967 try: 968 plumbing_response = svc.stub.List( 969 req, 970 metadata=svc.parent.get_metadata( 971 'AccountResourcesHistory.List', req), 972 timeout=t) 973 except Exception as e: 974 if self.parent.shouldRetry(tries, e, deadline): 975 tries += 1 976 time.sleep( 977 self.parent.exponentialBackoff(tries, deadline)) 978 continue 979 raise plumbing.convert_error_to_porcelain(e) from e 980 tries = 0 981 for plumbing_item in plumbing_response.history: 982 yield plumbing.convert_account_resource_history_to_porcelain( 983 plumbing_item) 984 if plumbing_response.meta.next_cursor == '': 985 break 986 req.meta.cursor = plumbing_response.meta.next_cursor 987 988 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
991class Accounts: 992 ''' 993 Accounts are users that have access to strongDM. There are two types of accounts: 994 1. **Users:** humans who are authenticated through username and password or SSO. 995 2. **Service Accounts:** machines that are authenticated using a service token. 996 3. **Tokens** are access keys with permissions that can be used for authentication. 997 See: 998 `strongdm.models.Service` 999 `strongdm.models.Token` 1000 `strongdm.models.User` 1001 ''' 1002 def __init__(self, channel, client): 1003 self.parent = client 1004 self.stub = AccountsStub(channel) 1005 1006 def create(self, account, timeout=None): 1007 ''' 1008 Create registers a new Account. 1009 ''' 1010 deadline = None if timeout is None else time.time() + timeout 1011 req = AccountCreateRequest() 1012 1013 if account is not None: 1014 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1015 tries = 0 1016 plumbing_response = None 1017 while True: 1018 t = None if deadline is None else deadline - time.time() 1019 try: 1020 plumbing_response = self.stub.Create( 1021 req, 1022 metadata=self.parent.get_metadata('Accounts.Create', req), 1023 timeout=t) 1024 except Exception as e: 1025 if self.parent.shouldRetry(tries, e, deadline): 1026 tries += 1 1027 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1028 continue 1029 raise plumbing.convert_error_to_porcelain(e) from e 1030 break 1031 1032 resp = models.AccountCreateResponse() 1033 resp.access_key = (plumbing_response.access_key) 1034 resp.account = plumbing.convert_account_to_porcelain( 1035 plumbing_response.account) 1036 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1037 plumbing_response.meta) 1038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1039 plumbing_response.rate_limit) 1040 resp.secret_key = (plumbing_response.secret_key) 1041 resp.token = (plumbing_response.token) 1042 return resp 1043 1044 def get(self, id, timeout=None): 1045 ''' 1046 Get reads one Account by ID. 1047 ''' 1048 deadline = None if timeout is None else time.time() + timeout 1049 req = AccountGetRequest() 1050 if self.parent.snapshot_datetime is not None: 1051 req.meta.CopyFrom(GetRequestMetadata()) 1052 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1053 1054 req.id = (id) 1055 tries = 0 1056 plumbing_response = None 1057 while True: 1058 t = None if deadline is None else deadline - time.time() 1059 try: 1060 plumbing_response = self.stub.Get( 1061 req, 1062 metadata=self.parent.get_metadata('Accounts.Get', req), 1063 timeout=t) 1064 except Exception as e: 1065 if self.parent.shouldRetry(tries, e, deadline): 1066 tries += 1 1067 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1068 continue 1069 raise plumbing.convert_error_to_porcelain(e) from e 1070 break 1071 1072 resp = models.AccountGetResponse() 1073 resp.account = plumbing.convert_account_to_porcelain( 1074 plumbing_response.account) 1075 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1076 plumbing_response.meta) 1077 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1078 plumbing_response.rate_limit) 1079 return resp 1080 1081 def update(self, account, timeout=None): 1082 ''' 1083 Update replaces all the fields of an Account by ID. 1084 ''' 1085 deadline = None if timeout is None else time.time() + timeout 1086 req = AccountUpdateRequest() 1087 1088 if account is not None: 1089 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1090 tries = 0 1091 plumbing_response = None 1092 while True: 1093 t = None if deadline is None else deadline - time.time() 1094 try: 1095 plumbing_response = self.stub.Update( 1096 req, 1097 metadata=self.parent.get_metadata('Accounts.Update', req), 1098 timeout=t) 1099 except Exception as e: 1100 if self.parent.shouldRetry(tries, e, deadline): 1101 tries += 1 1102 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1103 continue 1104 raise plumbing.convert_error_to_porcelain(e) from e 1105 break 1106 1107 resp = models.AccountUpdateResponse() 1108 resp.account = plumbing.convert_account_to_porcelain( 1109 plumbing_response.account) 1110 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1111 plumbing_response.meta) 1112 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1113 plumbing_response.rate_limit) 1114 return resp 1115 1116 def delete(self, id, timeout=None): 1117 ''' 1118 Delete removes an Account by ID. 1119 ''' 1120 deadline = None if timeout is None else time.time() + timeout 1121 req = AccountDeleteRequest() 1122 1123 req.id = (id) 1124 tries = 0 1125 plumbing_response = None 1126 while True: 1127 t = None if deadline is None else deadline - time.time() 1128 try: 1129 plumbing_response = self.stub.Delete( 1130 req, 1131 metadata=self.parent.get_metadata('Accounts.Delete', req), 1132 timeout=t) 1133 except Exception as e: 1134 if self.parent.shouldRetry(tries, e, deadline): 1135 tries += 1 1136 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1137 continue 1138 raise plumbing.convert_error_to_porcelain(e) from e 1139 break 1140 1141 resp = models.AccountDeleteResponse() 1142 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1143 plumbing_response.meta) 1144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1145 plumbing_response.rate_limit) 1146 return resp 1147 1148 def list(self, filter, *args, timeout=None): 1149 ''' 1150 List gets a list of Accounts matching a given set of criteria. 1151 ''' 1152 deadline = None if timeout is None else time.time() + timeout 1153 req = AccountListRequest() 1154 req.meta.CopyFrom(ListRequestMetadata()) 1155 if self.parent.page_limit > 0: 1156 req.meta.limit = self.parent.page_limit 1157 if self.parent.snapshot_datetime is not None: 1158 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1159 1160 req.filter = plumbing.quote_filter_args(filter, *args) 1161 1162 def generator(svc, req): 1163 tries = 0 1164 while True: 1165 t = None if deadline is None else deadline - time.time() 1166 try: 1167 plumbing_response = svc.stub.List( 1168 req, 1169 metadata=svc.parent.get_metadata('Accounts.List', req), 1170 timeout=t) 1171 except Exception as e: 1172 if self.parent.shouldRetry(tries, e, deadline): 1173 tries += 1 1174 time.sleep( 1175 self.parent.exponentialBackoff(tries, deadline)) 1176 continue 1177 raise plumbing.convert_error_to_porcelain(e) from e 1178 tries = 0 1179 for plumbing_item in plumbing_response.accounts: 1180 yield plumbing.convert_account_to_porcelain(plumbing_item) 1181 if plumbing_response.meta.next_cursor == '': 1182 break 1183 req.meta.cursor = plumbing_response.meta.next_cursor 1184 1185 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)
1006 def create(self, account, timeout=None): 1007 ''' 1008 Create registers a new Account. 1009 ''' 1010 deadline = None if timeout is None else time.time() + timeout 1011 req = AccountCreateRequest() 1012 1013 if account is not None: 1014 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1015 tries = 0 1016 plumbing_response = None 1017 while True: 1018 t = None if deadline is None else deadline - time.time() 1019 try: 1020 plumbing_response = self.stub.Create( 1021 req, 1022 metadata=self.parent.get_metadata('Accounts.Create', req), 1023 timeout=t) 1024 except Exception as e: 1025 if self.parent.shouldRetry(tries, e, deadline): 1026 tries += 1 1027 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1028 continue 1029 raise plumbing.convert_error_to_porcelain(e) from e 1030 break 1031 1032 resp = models.AccountCreateResponse() 1033 resp.access_key = (plumbing_response.access_key) 1034 resp.account = plumbing.convert_account_to_porcelain( 1035 plumbing_response.account) 1036 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1037 plumbing_response.meta) 1038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1039 plumbing_response.rate_limit) 1040 resp.secret_key = (plumbing_response.secret_key) 1041 resp.token = (plumbing_response.token) 1042 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1044 def get(self, id, timeout=None): 1045 ''' 1046 Get reads one Account by ID. 1047 ''' 1048 deadline = None if timeout is None else time.time() + timeout 1049 req = AccountGetRequest() 1050 if self.parent.snapshot_datetime is not None: 1051 req.meta.CopyFrom(GetRequestMetadata()) 1052 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1053 1054 req.id = (id) 1055 tries = 0 1056 plumbing_response = None 1057 while True: 1058 t = None if deadline is None else deadline - time.time() 1059 try: 1060 plumbing_response = self.stub.Get( 1061 req, 1062 metadata=self.parent.get_metadata('Accounts.Get', req), 1063 timeout=t) 1064 except Exception as e: 1065 if self.parent.shouldRetry(tries, e, deadline): 1066 tries += 1 1067 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1068 continue 1069 raise plumbing.convert_error_to_porcelain(e) from e 1070 break 1071 1072 resp = models.AccountGetResponse() 1073 resp.account = plumbing.convert_account_to_porcelain( 1074 plumbing_response.account) 1075 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1076 plumbing_response.meta) 1077 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1078 plumbing_response.rate_limit) 1079 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1081 def update(self, account, timeout=None): 1082 ''' 1083 Update replaces all the fields of an Account by ID. 1084 ''' 1085 deadline = None if timeout is None else time.time() + timeout 1086 req = AccountUpdateRequest() 1087 1088 if account is not None: 1089 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1090 tries = 0 1091 plumbing_response = None 1092 while True: 1093 t = None if deadline is None else deadline - time.time() 1094 try: 1095 plumbing_response = self.stub.Update( 1096 req, 1097 metadata=self.parent.get_metadata('Accounts.Update', req), 1098 timeout=t) 1099 except Exception as e: 1100 if self.parent.shouldRetry(tries, e, deadline): 1101 tries += 1 1102 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1103 continue 1104 raise plumbing.convert_error_to_porcelain(e) from e 1105 break 1106 1107 resp = models.AccountUpdateResponse() 1108 resp.account = plumbing.convert_account_to_porcelain( 1109 plumbing_response.account) 1110 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1111 plumbing_response.meta) 1112 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1113 plumbing_response.rate_limit) 1114 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1116 def delete(self, id, timeout=None): 1117 ''' 1118 Delete removes an Account by ID. 1119 ''' 1120 deadline = None if timeout is None else time.time() + timeout 1121 req = AccountDeleteRequest() 1122 1123 req.id = (id) 1124 tries = 0 1125 plumbing_response = None 1126 while True: 1127 t = None if deadline is None else deadline - time.time() 1128 try: 1129 plumbing_response = self.stub.Delete( 1130 req, 1131 metadata=self.parent.get_metadata('Accounts.Delete', req), 1132 timeout=t) 1133 except Exception as e: 1134 if self.parent.shouldRetry(tries, e, deadline): 1135 tries += 1 1136 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1137 continue 1138 raise plumbing.convert_error_to_porcelain(e) from e 1139 break 1140 1141 resp = models.AccountDeleteResponse() 1142 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1143 plumbing_response.meta) 1144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1145 plumbing_response.rate_limit) 1146 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1148 def list(self, filter, *args, timeout=None): 1149 ''' 1150 List gets a list of Accounts matching a given set of criteria. 1151 ''' 1152 deadline = None if timeout is None else time.time() + timeout 1153 req = AccountListRequest() 1154 req.meta.CopyFrom(ListRequestMetadata()) 1155 if self.parent.page_limit > 0: 1156 req.meta.limit = self.parent.page_limit 1157 if self.parent.snapshot_datetime is not None: 1158 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1159 1160 req.filter = plumbing.quote_filter_args(filter, *args) 1161 1162 def generator(svc, req): 1163 tries = 0 1164 while True: 1165 t = None if deadline is None else deadline - time.time() 1166 try: 1167 plumbing_response = svc.stub.List( 1168 req, 1169 metadata=svc.parent.get_metadata('Accounts.List', req), 1170 timeout=t) 1171 except Exception as e: 1172 if self.parent.shouldRetry(tries, e, deadline): 1173 tries += 1 1174 time.sleep( 1175 self.parent.exponentialBackoff(tries, deadline)) 1176 continue 1177 raise plumbing.convert_error_to_porcelain(e) from e 1178 tries = 0 1179 for plumbing_item in plumbing_response.accounts: 1180 yield plumbing.convert_account_to_porcelain(plumbing_item) 1181 if plumbing_response.meta.next_cursor == '': 1182 break 1183 req.meta.cursor = plumbing_response.meta.next_cursor 1184 1185 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1188class SnapshotAccounts: 1189 ''' 1190 SnapshotAccounts exposes the read only methods of the Accounts 1191 service for historical queries. 1192 ''' 1193 def __init__(self, accounts): 1194 self.accounts = accounts 1195 1196 def get(self, id, timeout=None): 1197 ''' 1198 Get reads one Account by ID. 1199 ''' 1200 return self.accounts.get(id, timeout=timeout) 1201 1202 def list(self, filter, *args, timeout=None): 1203 ''' 1204 List gets a list of Accounts matching a given set of criteria. 1205 ''' 1206 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)
1196 def get(self, id, timeout=None): 1197 ''' 1198 Get reads one Account by ID. 1199 ''' 1200 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1202 def list(self, filter, *args, timeout=None): 1203 ''' 1204 List gets a list of Accounts matching a given set of criteria. 1205 ''' 1206 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsHistory:
1209class AccountsHistory: 1210 ''' 1211 AccountsHistory records all changes to the state of an Account. 1212 See `strongdm.models.AccountHistory`. 1213 ''' 1214 def __init__(self, channel, client): 1215 self.parent = client 1216 self.stub = AccountsHistoryStub(channel) 1217 1218 def list(self, filter, *args, timeout=None): 1219 ''' 1220 List gets a list of AccountHistory records matching a given set of criteria. 1221 ''' 1222 deadline = None if timeout is None else time.time() + timeout 1223 req = AccountHistoryListRequest() 1224 req.meta.CopyFrom(ListRequestMetadata()) 1225 if self.parent.page_limit > 0: 1226 req.meta.limit = self.parent.page_limit 1227 if self.parent.snapshot_datetime is not None: 1228 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1229 1230 req.filter = plumbing.quote_filter_args(filter, *args) 1231 1232 def generator(svc, req): 1233 tries = 0 1234 while True: 1235 t = None if deadline is None else deadline - time.time() 1236 try: 1237 plumbing_response = svc.stub.List( 1238 req, 1239 metadata=svc.parent.get_metadata( 1240 'AccountsHistory.List', req), 1241 timeout=t) 1242 except Exception as e: 1243 if self.parent.shouldRetry(tries, e, deadline): 1244 tries += 1 1245 time.sleep( 1246 self.parent.exponentialBackoff(tries, deadline)) 1247 continue 1248 raise plumbing.convert_error_to_porcelain(e) from e 1249 tries = 0 1250 for plumbing_item in plumbing_response.history: 1251 yield plumbing.convert_account_history_to_porcelain( 1252 plumbing_item) 1253 if plumbing_response.meta.next_cursor == '': 1254 break 1255 req.meta.cursor = plumbing_response.meta.next_cursor 1256 1257 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)
1218 def list(self, filter, *args, timeout=None): 1219 ''' 1220 List gets a list of AccountHistory records matching a given set of criteria. 1221 ''' 1222 deadline = None if timeout is None else time.time() + timeout 1223 req = AccountHistoryListRequest() 1224 req.meta.CopyFrom(ListRequestMetadata()) 1225 if self.parent.page_limit > 0: 1226 req.meta.limit = self.parent.page_limit 1227 if self.parent.snapshot_datetime is not None: 1228 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1229 1230 req.filter = plumbing.quote_filter_args(filter, *args) 1231 1232 def generator(svc, req): 1233 tries = 0 1234 while True: 1235 t = None if deadline is None else deadline - time.time() 1236 try: 1237 plumbing_response = svc.stub.List( 1238 req, 1239 metadata=svc.parent.get_metadata( 1240 'AccountsHistory.List', req), 1241 timeout=t) 1242 except Exception as e: 1243 if self.parent.shouldRetry(tries, e, deadline): 1244 tries += 1 1245 time.sleep( 1246 self.parent.exponentialBackoff(tries, deadline)) 1247 continue 1248 raise plumbing.convert_error_to_porcelain(e) from e 1249 tries = 0 1250 for plumbing_item in plumbing_response.history: 1251 yield plumbing.convert_account_history_to_porcelain( 1252 plumbing_item) 1253 if plumbing_response.meta.next_cursor == '': 1254 break 1255 req.meta.cursor = plumbing_response.meta.next_cursor 1256 1257 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1260class Activities: 1261 ''' 1262 An Activity is a record of an action taken against a strongDM deployment, e.g. 1263 a user creation, resource deletion, sso configuration change, etc. The Activities 1264 service is read-only. 1265 See `strongdm.models.Activity`. 1266 ''' 1267 def __init__(self, channel, client): 1268 self.parent = client 1269 self.stub = ActivitiesStub(channel) 1270 1271 def get(self, id, timeout=None): 1272 ''' 1273 Get reads one Activity by ID. 1274 ''' 1275 deadline = None if timeout is None else time.time() + timeout 1276 req = ActivityGetRequest() 1277 if self.parent.snapshot_datetime is not None: 1278 req.meta.CopyFrom(GetRequestMetadata()) 1279 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1280 1281 req.id = (id) 1282 tries = 0 1283 plumbing_response = None 1284 while True: 1285 t = None if deadline is None else deadline - time.time() 1286 try: 1287 plumbing_response = self.stub.Get( 1288 req, 1289 metadata=self.parent.get_metadata('Activities.Get', req), 1290 timeout=t) 1291 except Exception as e: 1292 if self.parent.shouldRetry(tries, e, deadline): 1293 tries += 1 1294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1295 continue 1296 raise plumbing.convert_error_to_porcelain(e) from e 1297 break 1298 1299 resp = models.ActivityGetResponse() 1300 resp.activity = plumbing.convert_activity_to_porcelain( 1301 plumbing_response.activity) 1302 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1303 plumbing_response.meta) 1304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1305 plumbing_response.rate_limit) 1306 return resp 1307 1308 def list(self, filter, *args, timeout=None): 1309 ''' 1310 List gets a list of Activities matching a given set of criteria. 1311 The 'before' and 'after' filters can be used to control the time 1312 range of the output activities. If not provided, one week of back 1313 of activities will be returned. 1314 ''' 1315 deadline = None if timeout is None else time.time() + timeout 1316 req = ActivityListRequest() 1317 req.meta.CopyFrom(ListRequestMetadata()) 1318 if self.parent.page_limit > 0: 1319 req.meta.limit = self.parent.page_limit 1320 if self.parent.snapshot_datetime is not None: 1321 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1322 1323 req.filter = plumbing.quote_filter_args(filter, *args) 1324 1325 def generator(svc, req): 1326 tries = 0 1327 while True: 1328 t = None if deadline is None else deadline - time.time() 1329 try: 1330 plumbing_response = svc.stub.List( 1331 req, 1332 metadata=svc.parent.get_metadata( 1333 'Activities.List', req), 1334 timeout=t) 1335 except Exception as e: 1336 if self.parent.shouldRetry(tries, e, deadline): 1337 tries += 1 1338 time.sleep( 1339 self.parent.exponentialBackoff(tries, deadline)) 1340 continue 1341 raise plumbing.convert_error_to_porcelain(e) from e 1342 tries = 0 1343 for plumbing_item in plumbing_response.activities: 1344 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1345 if plumbing_response.meta.next_cursor == '': 1346 break 1347 req.meta.cursor = plumbing_response.meta.next_cursor 1348 1349 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)
1271 def get(self, id, timeout=None): 1272 ''' 1273 Get reads one Activity by ID. 1274 ''' 1275 deadline = None if timeout is None else time.time() + timeout 1276 req = ActivityGetRequest() 1277 if self.parent.snapshot_datetime is not None: 1278 req.meta.CopyFrom(GetRequestMetadata()) 1279 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1280 1281 req.id = (id) 1282 tries = 0 1283 plumbing_response = None 1284 while True: 1285 t = None if deadline is None else deadline - time.time() 1286 try: 1287 plumbing_response = self.stub.Get( 1288 req, 1289 metadata=self.parent.get_metadata('Activities.Get', req), 1290 timeout=t) 1291 except Exception as e: 1292 if self.parent.shouldRetry(tries, e, deadline): 1293 tries += 1 1294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1295 continue 1296 raise plumbing.convert_error_to_porcelain(e) from e 1297 break 1298 1299 resp = models.ActivityGetResponse() 1300 resp.activity = plumbing.convert_activity_to_porcelain( 1301 plumbing_response.activity) 1302 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1303 plumbing_response.meta) 1304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1305 plumbing_response.rate_limit) 1306 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1308 def list(self, filter, *args, timeout=None): 1309 ''' 1310 List gets a list of Activities matching a given set of criteria. 1311 The 'before' and 'after' filters can be used to control the time 1312 range of the output activities. If not provided, one week of back 1313 of activities will be returned. 1314 ''' 1315 deadline = None if timeout is None else time.time() + timeout 1316 req = ActivityListRequest() 1317 req.meta.CopyFrom(ListRequestMetadata()) 1318 if self.parent.page_limit > 0: 1319 req.meta.limit = self.parent.page_limit 1320 if self.parent.snapshot_datetime is not None: 1321 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1322 1323 req.filter = plumbing.quote_filter_args(filter, *args) 1324 1325 def generator(svc, req): 1326 tries = 0 1327 while True: 1328 t = None if deadline is None else deadline - time.time() 1329 try: 1330 plumbing_response = svc.stub.List( 1331 req, 1332 metadata=svc.parent.get_metadata( 1333 'Activities.List', req), 1334 timeout=t) 1335 except Exception as e: 1336 if self.parent.shouldRetry(tries, e, deadline): 1337 tries += 1 1338 time.sleep( 1339 self.parent.exponentialBackoff(tries, deadline)) 1340 continue 1341 raise plumbing.convert_error_to_porcelain(e) from e 1342 tries = 0 1343 for plumbing_item in plumbing_response.activities: 1344 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1345 if plumbing_response.meta.next_cursor == '': 1346 break 1347 req.meta.cursor = plumbing_response.meta.next_cursor 1348 1349 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:
1352class ApprovalWorkflowApprovers: 1353 ''' 1354 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1355 See `strongdm.models.ApprovalWorkflowApprover`. 1356 ''' 1357 def __init__(self, channel, client): 1358 self.parent = client 1359 self.stub = ApprovalWorkflowApproversStub(channel) 1360 1361 def create(self, approval_workflow_approver, timeout=None): 1362 ''' 1363 Deprecated: Create creates a new approval workflow approver. 1364 ''' 1365 deadline = None if timeout is None else time.time() + timeout 1366 req = ApprovalWorkflowApproverCreateRequest() 1367 1368 if approval_workflow_approver is not None: 1369 req.approval_workflow_approver.CopyFrom( 1370 plumbing.convert_approval_workflow_approver_to_plumbing( 1371 approval_workflow_approver)) 1372 tries = 0 1373 plumbing_response = None 1374 while True: 1375 t = None if deadline is None else deadline - time.time() 1376 try: 1377 plumbing_response = self.stub.Create( 1378 req, 1379 metadata=self.parent.get_metadata( 1380 'ApprovalWorkflowApprovers.Create', req), 1381 timeout=t) 1382 except Exception as e: 1383 if self.parent.shouldRetry(tries, e, deadline): 1384 tries += 1 1385 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1386 continue 1387 raise plumbing.convert_error_to_porcelain(e) from e 1388 break 1389 1390 resp = models.ApprovalWorkflowApproverCreateResponse() 1391 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1392 plumbing_response.approval_workflow_approver) 1393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1394 plumbing_response.rate_limit) 1395 return resp 1396 1397 def get(self, id, timeout=None): 1398 ''' 1399 Deprecated: Get reads one approval workflow approver by ID. 1400 ''' 1401 deadline = None if timeout is None else time.time() + timeout 1402 req = ApprovalWorkflowApproverGetRequest() 1403 if self.parent.snapshot_datetime is not None: 1404 req.meta.CopyFrom(GetRequestMetadata()) 1405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1406 1407 req.id = (id) 1408 tries = 0 1409 plumbing_response = None 1410 while True: 1411 t = None if deadline is None else deadline - time.time() 1412 try: 1413 plumbing_response = self.stub.Get( 1414 req, 1415 metadata=self.parent.get_metadata( 1416 'ApprovalWorkflowApprovers.Get', req), 1417 timeout=t) 1418 except Exception as e: 1419 if self.parent.shouldRetry(tries, e, deadline): 1420 tries += 1 1421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1422 continue 1423 raise plumbing.convert_error_to_porcelain(e) from e 1424 break 1425 1426 resp = models.ApprovalWorkflowApproverGetResponse() 1427 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1428 plumbing_response.approval_workflow_approver) 1429 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1430 plumbing_response.meta) 1431 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1432 plumbing_response.rate_limit) 1433 return resp 1434 1435 def delete(self, id, timeout=None): 1436 ''' 1437 Deprecated: Delete deletes an existing approval workflow approver. 1438 ''' 1439 deadline = None if timeout is None else time.time() + timeout 1440 req = ApprovalWorkflowApproverDeleteRequest() 1441 1442 req.id = (id) 1443 tries = 0 1444 plumbing_response = None 1445 while True: 1446 t = None if deadline is None else deadline - time.time() 1447 try: 1448 plumbing_response = self.stub.Delete( 1449 req, 1450 metadata=self.parent.get_metadata( 1451 'ApprovalWorkflowApprovers.Delete', req), 1452 timeout=t) 1453 except Exception as e: 1454 if self.parent.shouldRetry(tries, e, deadline): 1455 tries += 1 1456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1457 continue 1458 raise plumbing.convert_error_to_porcelain(e) from e 1459 break 1460 1461 resp = models.ApprovalWorkflowApproverDeleteResponse() 1462 resp.id = (plumbing_response.id) 1463 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1464 plumbing_response.rate_limit) 1465 return resp 1466 1467 def list(self, filter, *args, timeout=None): 1468 ''' 1469 Deprecated: Lists existing approval workflow approvers. 1470 ''' 1471 deadline = None if timeout is None else time.time() + timeout 1472 req = ApprovalWorkflowApproverListRequest() 1473 req.meta.CopyFrom(ListRequestMetadata()) 1474 if self.parent.page_limit > 0: 1475 req.meta.limit = self.parent.page_limit 1476 if self.parent.snapshot_datetime is not None: 1477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1478 1479 req.filter = plumbing.quote_filter_args(filter, *args) 1480 1481 def generator(svc, req): 1482 tries = 0 1483 while True: 1484 t = None if deadline is None else deadline - time.time() 1485 try: 1486 plumbing_response = svc.stub.List( 1487 req, 1488 metadata=svc.parent.get_metadata( 1489 'ApprovalWorkflowApprovers.List', req), 1490 timeout=t) 1491 except Exception as e: 1492 if self.parent.shouldRetry(tries, e, deadline): 1493 tries += 1 1494 time.sleep( 1495 self.parent.exponentialBackoff(tries, deadline)) 1496 continue 1497 raise plumbing.convert_error_to_porcelain(e) from e 1498 tries = 0 1499 for plumbing_item in plumbing_response.approval_workflow_approvers: 1500 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1501 plumbing_item) 1502 if plumbing_response.meta.next_cursor == '': 1503 break 1504 req.meta.cursor = plumbing_response.meta.next_cursor 1505 1506 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1361 def create(self, approval_workflow_approver, timeout=None): 1362 ''' 1363 Deprecated: Create creates a new approval workflow approver. 1364 ''' 1365 deadline = None if timeout is None else time.time() + timeout 1366 req = ApprovalWorkflowApproverCreateRequest() 1367 1368 if approval_workflow_approver is not None: 1369 req.approval_workflow_approver.CopyFrom( 1370 plumbing.convert_approval_workflow_approver_to_plumbing( 1371 approval_workflow_approver)) 1372 tries = 0 1373 plumbing_response = None 1374 while True: 1375 t = None if deadline is None else deadline - time.time() 1376 try: 1377 plumbing_response = self.stub.Create( 1378 req, 1379 metadata=self.parent.get_metadata( 1380 'ApprovalWorkflowApprovers.Create', req), 1381 timeout=t) 1382 except Exception as e: 1383 if self.parent.shouldRetry(tries, e, deadline): 1384 tries += 1 1385 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1386 continue 1387 raise plumbing.convert_error_to_porcelain(e) from e 1388 break 1389 1390 resp = models.ApprovalWorkflowApproverCreateResponse() 1391 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1392 plumbing_response.approval_workflow_approver) 1393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1394 plumbing_response.rate_limit) 1395 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1397 def get(self, id, timeout=None): 1398 ''' 1399 Deprecated: Get reads one approval workflow approver by ID. 1400 ''' 1401 deadline = None if timeout is None else time.time() + timeout 1402 req = ApprovalWorkflowApproverGetRequest() 1403 if self.parent.snapshot_datetime is not None: 1404 req.meta.CopyFrom(GetRequestMetadata()) 1405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1406 1407 req.id = (id) 1408 tries = 0 1409 plumbing_response = None 1410 while True: 1411 t = None if deadline is None else deadline - time.time() 1412 try: 1413 plumbing_response = self.stub.Get( 1414 req, 1415 metadata=self.parent.get_metadata( 1416 'ApprovalWorkflowApprovers.Get', req), 1417 timeout=t) 1418 except Exception as e: 1419 if self.parent.shouldRetry(tries, e, deadline): 1420 tries += 1 1421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1422 continue 1423 raise plumbing.convert_error_to_porcelain(e) from e 1424 break 1425 1426 resp = models.ApprovalWorkflowApproverGetResponse() 1427 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1428 plumbing_response.approval_workflow_approver) 1429 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1430 plumbing_response.meta) 1431 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1432 plumbing_response.rate_limit) 1433 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1435 def delete(self, id, timeout=None): 1436 ''' 1437 Deprecated: Delete deletes an existing approval workflow approver. 1438 ''' 1439 deadline = None if timeout is None else time.time() + timeout 1440 req = ApprovalWorkflowApproverDeleteRequest() 1441 1442 req.id = (id) 1443 tries = 0 1444 plumbing_response = None 1445 while True: 1446 t = None if deadline is None else deadline - time.time() 1447 try: 1448 plumbing_response = self.stub.Delete( 1449 req, 1450 metadata=self.parent.get_metadata( 1451 'ApprovalWorkflowApprovers.Delete', req), 1452 timeout=t) 1453 except Exception as e: 1454 if self.parent.shouldRetry(tries, e, deadline): 1455 tries += 1 1456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1457 continue 1458 raise plumbing.convert_error_to_porcelain(e) from e 1459 break 1460 1461 resp = models.ApprovalWorkflowApproverDeleteResponse() 1462 resp.id = (plumbing_response.id) 1463 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1464 plumbing_response.rate_limit) 1465 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1467 def list(self, filter, *args, timeout=None): 1468 ''' 1469 Deprecated: Lists existing approval workflow approvers. 1470 ''' 1471 deadline = None if timeout is None else time.time() + timeout 1472 req = ApprovalWorkflowApproverListRequest() 1473 req.meta.CopyFrom(ListRequestMetadata()) 1474 if self.parent.page_limit > 0: 1475 req.meta.limit = self.parent.page_limit 1476 if self.parent.snapshot_datetime is not None: 1477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1478 1479 req.filter = plumbing.quote_filter_args(filter, *args) 1480 1481 def generator(svc, req): 1482 tries = 0 1483 while True: 1484 t = None if deadline is None else deadline - time.time() 1485 try: 1486 plumbing_response = svc.stub.List( 1487 req, 1488 metadata=svc.parent.get_metadata( 1489 'ApprovalWorkflowApprovers.List', req), 1490 timeout=t) 1491 except Exception as e: 1492 if self.parent.shouldRetry(tries, e, deadline): 1493 tries += 1 1494 time.sleep( 1495 self.parent.exponentialBackoff(tries, deadline)) 1496 continue 1497 raise plumbing.convert_error_to_porcelain(e) from e 1498 tries = 0 1499 for plumbing_item in plumbing_response.approval_workflow_approvers: 1500 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1501 plumbing_item) 1502 if plumbing_response.meta.next_cursor == '': 1503 break 1504 req.meta.cursor = plumbing_response.meta.next_cursor 1505 1506 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1509class SnapshotApprovalWorkflowApprovers: 1510 ''' 1511 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1512 service for historical queries. 1513 ''' 1514 def __init__(self, approval_workflow_approvers): 1515 self.approval_workflow_approvers = approval_workflow_approvers 1516 1517 def get(self, id, timeout=None): 1518 ''' 1519 Deprecated: Get reads one approval workflow approver by ID. 1520 ''' 1521 return self.approval_workflow_approvers.get(id, timeout=timeout) 1522 1523 def list(self, filter, *args, timeout=None): 1524 ''' 1525 Deprecated: Lists existing approval workflow approvers. 1526 ''' 1527 return self.approval_workflow_approvers.list(filter, 1528 *args, 1529 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1517 def get(self, id, timeout=None): 1518 ''' 1519 Deprecated: Get reads one approval workflow approver by ID. 1520 ''' 1521 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)
1523 def list(self, filter, *args, timeout=None): 1524 ''' 1525 Deprecated: Lists existing approval workflow approvers. 1526 ''' 1527 return self.approval_workflow_approvers.list(filter, 1528 *args, 1529 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1532class ApprovalWorkflowApproversHistory: 1533 ''' 1534 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1535 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1536 ''' 1537 def __init__(self, channel, client): 1538 self.parent = client 1539 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1540 1541 def list(self, filter, *args, timeout=None): 1542 ''' 1543 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1544 ''' 1545 deadline = None if timeout is None else time.time() + timeout 1546 req = ApprovalWorkflowApproverHistoryListRequest() 1547 req.meta.CopyFrom(ListRequestMetadata()) 1548 if self.parent.page_limit > 0: 1549 req.meta.limit = self.parent.page_limit 1550 if self.parent.snapshot_datetime is not None: 1551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1552 1553 req.filter = plumbing.quote_filter_args(filter, *args) 1554 1555 def generator(svc, req): 1556 tries = 0 1557 while True: 1558 t = None if deadline is None else deadline - time.time() 1559 try: 1560 plumbing_response = svc.stub.List( 1561 req, 1562 metadata=svc.parent.get_metadata( 1563 'ApprovalWorkflowApproversHistory.List', req), 1564 timeout=t) 1565 except Exception as e: 1566 if self.parent.shouldRetry(tries, e, deadline): 1567 tries += 1 1568 time.sleep( 1569 self.parent.exponentialBackoff(tries, deadline)) 1570 continue 1571 raise plumbing.convert_error_to_porcelain(e) from e 1572 tries = 0 1573 for plumbing_item in plumbing_response.history: 1574 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1575 plumbing_item) 1576 if plumbing_response.meta.next_cursor == '': 1577 break 1578 req.meta.cursor = plumbing_response.meta.next_cursor 1579 1580 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)
1541 def list(self, filter, *args, timeout=None): 1542 ''' 1543 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1544 ''' 1545 deadline = None if timeout is None else time.time() + timeout 1546 req = ApprovalWorkflowApproverHistoryListRequest() 1547 req.meta.CopyFrom(ListRequestMetadata()) 1548 if self.parent.page_limit > 0: 1549 req.meta.limit = self.parent.page_limit 1550 if self.parent.snapshot_datetime is not None: 1551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1552 1553 req.filter = plumbing.quote_filter_args(filter, *args) 1554 1555 def generator(svc, req): 1556 tries = 0 1557 while True: 1558 t = None if deadline is None else deadline - time.time() 1559 try: 1560 plumbing_response = svc.stub.List( 1561 req, 1562 metadata=svc.parent.get_metadata( 1563 'ApprovalWorkflowApproversHistory.List', req), 1564 timeout=t) 1565 except Exception as e: 1566 if self.parent.shouldRetry(tries, e, deadline): 1567 tries += 1 1568 time.sleep( 1569 self.parent.exponentialBackoff(tries, deadline)) 1570 continue 1571 raise plumbing.convert_error_to_porcelain(e) from e 1572 tries = 0 1573 for plumbing_item in plumbing_response.history: 1574 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1575 plumbing_item) 1576 if plumbing_response.meta.next_cursor == '': 1577 break 1578 req.meta.cursor = plumbing_response.meta.next_cursor 1579 1580 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1583class ApprovalWorkflowSteps: 1584 ''' 1585 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1586 See `strongdm.models.ApprovalWorkflowStep`. 1587 ''' 1588 def __init__(self, channel, client): 1589 self.parent = client 1590 self.stub = ApprovalWorkflowStepsStub(channel) 1591 1592 def create(self, approval_workflow_step, timeout=None): 1593 ''' 1594 Deprecated: Create creates a new approval workflow step. 1595 ''' 1596 deadline = None if timeout is None else time.time() + timeout 1597 req = ApprovalWorkflowStepCreateRequest() 1598 1599 if approval_workflow_step is not None: 1600 req.approval_workflow_step.CopyFrom( 1601 plumbing.convert_approval_workflow_step_to_plumbing( 1602 approval_workflow_step)) 1603 tries = 0 1604 plumbing_response = None 1605 while True: 1606 t = None if deadline is None else deadline - time.time() 1607 try: 1608 plumbing_response = self.stub.Create( 1609 req, 1610 metadata=self.parent.get_metadata( 1611 'ApprovalWorkflowSteps.Create', req), 1612 timeout=t) 1613 except Exception as e: 1614 if self.parent.shouldRetry(tries, e, deadline): 1615 tries += 1 1616 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1617 continue 1618 raise plumbing.convert_error_to_porcelain(e) from e 1619 break 1620 1621 resp = models.ApprovalWorkflowStepCreateResponse() 1622 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1623 plumbing_response.approval_workflow_step) 1624 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1625 plumbing_response.rate_limit) 1626 return resp 1627 1628 def get(self, id, timeout=None): 1629 ''' 1630 Deprecated: Get reads one approval workflow step by ID. 1631 ''' 1632 deadline = None if timeout is None else time.time() + timeout 1633 req = ApprovalWorkflowStepGetRequest() 1634 if self.parent.snapshot_datetime is not None: 1635 req.meta.CopyFrom(GetRequestMetadata()) 1636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1637 1638 req.id = (id) 1639 tries = 0 1640 plumbing_response = None 1641 while True: 1642 t = None if deadline is None else deadline - time.time() 1643 try: 1644 plumbing_response = self.stub.Get( 1645 req, 1646 metadata=self.parent.get_metadata( 1647 'ApprovalWorkflowSteps.Get', req), 1648 timeout=t) 1649 except Exception as e: 1650 if self.parent.shouldRetry(tries, e, deadline): 1651 tries += 1 1652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1653 continue 1654 raise plumbing.convert_error_to_porcelain(e) from e 1655 break 1656 1657 resp = models.ApprovalWorkflowStepGetResponse() 1658 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1659 plumbing_response.approval_workflow_step) 1660 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1661 plumbing_response.meta) 1662 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1663 plumbing_response.rate_limit) 1664 return resp 1665 1666 def delete(self, id, timeout=None): 1667 ''' 1668 Deprecated: Delete deletes an existing approval workflow step. 1669 ''' 1670 deadline = None if timeout is None else time.time() + timeout 1671 req = ApprovalWorkflowStepDeleteRequest() 1672 1673 req.id = (id) 1674 tries = 0 1675 plumbing_response = None 1676 while True: 1677 t = None if deadline is None else deadline - time.time() 1678 try: 1679 plumbing_response = self.stub.Delete( 1680 req, 1681 metadata=self.parent.get_metadata( 1682 'ApprovalWorkflowSteps.Delete', req), 1683 timeout=t) 1684 except Exception as e: 1685 if self.parent.shouldRetry(tries, e, deadline): 1686 tries += 1 1687 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1688 continue 1689 raise plumbing.convert_error_to_porcelain(e) from e 1690 break 1691 1692 resp = models.ApprovalWorkflowStepDeleteResponse() 1693 resp.id = (plumbing_response.id) 1694 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1695 plumbing_response.rate_limit) 1696 return resp 1697 1698 def list(self, filter, *args, timeout=None): 1699 ''' 1700 Deprecated: Lists existing approval workflow steps. 1701 ''' 1702 deadline = None if timeout is None else time.time() + timeout 1703 req = ApprovalWorkflowStepListRequest() 1704 req.meta.CopyFrom(ListRequestMetadata()) 1705 if self.parent.page_limit > 0: 1706 req.meta.limit = self.parent.page_limit 1707 if self.parent.snapshot_datetime is not None: 1708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1709 1710 req.filter = plumbing.quote_filter_args(filter, *args) 1711 1712 def generator(svc, req): 1713 tries = 0 1714 while True: 1715 t = None if deadline is None else deadline - time.time() 1716 try: 1717 plumbing_response = svc.stub.List( 1718 req, 1719 metadata=svc.parent.get_metadata( 1720 'ApprovalWorkflowSteps.List', req), 1721 timeout=t) 1722 except Exception as e: 1723 if self.parent.shouldRetry(tries, e, deadline): 1724 tries += 1 1725 time.sleep( 1726 self.parent.exponentialBackoff(tries, deadline)) 1727 continue 1728 raise plumbing.convert_error_to_porcelain(e) from e 1729 tries = 0 1730 for plumbing_item in plumbing_response.approval_workflow_steps: 1731 yield plumbing.convert_approval_workflow_step_to_porcelain( 1732 plumbing_item) 1733 if plumbing_response.meta.next_cursor == '': 1734 break 1735 req.meta.cursor = plumbing_response.meta.next_cursor 1736 1737 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1592 def create(self, approval_workflow_step, timeout=None): 1593 ''' 1594 Deprecated: Create creates a new approval workflow step. 1595 ''' 1596 deadline = None if timeout is None else time.time() + timeout 1597 req = ApprovalWorkflowStepCreateRequest() 1598 1599 if approval_workflow_step is not None: 1600 req.approval_workflow_step.CopyFrom( 1601 plumbing.convert_approval_workflow_step_to_plumbing( 1602 approval_workflow_step)) 1603 tries = 0 1604 plumbing_response = None 1605 while True: 1606 t = None if deadline is None else deadline - time.time() 1607 try: 1608 plumbing_response = self.stub.Create( 1609 req, 1610 metadata=self.parent.get_metadata( 1611 'ApprovalWorkflowSteps.Create', req), 1612 timeout=t) 1613 except Exception as e: 1614 if self.parent.shouldRetry(tries, e, deadline): 1615 tries += 1 1616 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1617 continue 1618 raise plumbing.convert_error_to_porcelain(e) from e 1619 break 1620 1621 resp = models.ApprovalWorkflowStepCreateResponse() 1622 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1623 plumbing_response.approval_workflow_step) 1624 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1625 plumbing_response.rate_limit) 1626 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1628 def get(self, id, timeout=None): 1629 ''' 1630 Deprecated: Get reads one approval workflow step by ID. 1631 ''' 1632 deadline = None if timeout is None else time.time() + timeout 1633 req = ApprovalWorkflowStepGetRequest() 1634 if self.parent.snapshot_datetime is not None: 1635 req.meta.CopyFrom(GetRequestMetadata()) 1636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1637 1638 req.id = (id) 1639 tries = 0 1640 plumbing_response = None 1641 while True: 1642 t = None if deadline is None else deadline - time.time() 1643 try: 1644 plumbing_response = self.stub.Get( 1645 req, 1646 metadata=self.parent.get_metadata( 1647 'ApprovalWorkflowSteps.Get', req), 1648 timeout=t) 1649 except Exception as e: 1650 if self.parent.shouldRetry(tries, e, deadline): 1651 tries += 1 1652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1653 continue 1654 raise plumbing.convert_error_to_porcelain(e) from e 1655 break 1656 1657 resp = models.ApprovalWorkflowStepGetResponse() 1658 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1659 plumbing_response.approval_workflow_step) 1660 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1661 plumbing_response.meta) 1662 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1663 plumbing_response.rate_limit) 1664 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1666 def delete(self, id, timeout=None): 1667 ''' 1668 Deprecated: Delete deletes an existing approval workflow step. 1669 ''' 1670 deadline = None if timeout is None else time.time() + timeout 1671 req = ApprovalWorkflowStepDeleteRequest() 1672 1673 req.id = (id) 1674 tries = 0 1675 plumbing_response = None 1676 while True: 1677 t = None if deadline is None else deadline - time.time() 1678 try: 1679 plumbing_response = self.stub.Delete( 1680 req, 1681 metadata=self.parent.get_metadata( 1682 'ApprovalWorkflowSteps.Delete', req), 1683 timeout=t) 1684 except Exception as e: 1685 if self.parent.shouldRetry(tries, e, deadline): 1686 tries += 1 1687 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1688 continue 1689 raise plumbing.convert_error_to_porcelain(e) from e 1690 break 1691 1692 resp = models.ApprovalWorkflowStepDeleteResponse() 1693 resp.id = (plumbing_response.id) 1694 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1695 plumbing_response.rate_limit) 1696 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1698 def list(self, filter, *args, timeout=None): 1699 ''' 1700 Deprecated: Lists existing approval workflow steps. 1701 ''' 1702 deadline = None if timeout is None else time.time() + timeout 1703 req = ApprovalWorkflowStepListRequest() 1704 req.meta.CopyFrom(ListRequestMetadata()) 1705 if self.parent.page_limit > 0: 1706 req.meta.limit = self.parent.page_limit 1707 if self.parent.snapshot_datetime is not None: 1708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1709 1710 req.filter = plumbing.quote_filter_args(filter, *args) 1711 1712 def generator(svc, req): 1713 tries = 0 1714 while True: 1715 t = None if deadline is None else deadline - time.time() 1716 try: 1717 plumbing_response = svc.stub.List( 1718 req, 1719 metadata=svc.parent.get_metadata( 1720 'ApprovalWorkflowSteps.List', req), 1721 timeout=t) 1722 except Exception as e: 1723 if self.parent.shouldRetry(tries, e, deadline): 1724 tries += 1 1725 time.sleep( 1726 self.parent.exponentialBackoff(tries, deadline)) 1727 continue 1728 raise plumbing.convert_error_to_porcelain(e) from e 1729 tries = 0 1730 for plumbing_item in plumbing_response.approval_workflow_steps: 1731 yield plumbing.convert_approval_workflow_step_to_porcelain( 1732 plumbing_item) 1733 if plumbing_response.meta.next_cursor == '': 1734 break 1735 req.meta.cursor = plumbing_response.meta.next_cursor 1736 1737 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1740class SnapshotApprovalWorkflowSteps: 1741 ''' 1742 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1743 service for historical queries. 1744 ''' 1745 def __init__(self, approval_workflow_steps): 1746 self.approval_workflow_steps = approval_workflow_steps 1747 1748 def get(self, id, timeout=None): 1749 ''' 1750 Deprecated: Get reads one approval workflow step by ID. 1751 ''' 1752 return self.approval_workflow_steps.get(id, timeout=timeout) 1753 1754 def list(self, filter, *args, timeout=None): 1755 ''' 1756 Deprecated: Lists existing approval workflow steps. 1757 ''' 1758 return self.approval_workflow_steps.list(filter, 1759 *args, 1760 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1748 def get(self, id, timeout=None): 1749 ''' 1750 Deprecated: Get reads one approval workflow step by ID. 1751 ''' 1752 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)
1754 def list(self, filter, *args, timeout=None): 1755 ''' 1756 Deprecated: Lists existing approval workflow steps. 1757 ''' 1758 return self.approval_workflow_steps.list(filter, 1759 *args, 1760 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
1763class ApprovalWorkflowStepsHistory: 1764 ''' 1765 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 1766 See `strongdm.models.ApprovalWorkflowStepHistory`. 1767 ''' 1768 def __init__(self, channel, client): 1769 self.parent = client 1770 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 1771 1772 def list(self, filter, *args, timeout=None): 1773 ''' 1774 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1775 ''' 1776 deadline = None if timeout is None else time.time() + timeout 1777 req = ApprovalWorkflowStepHistoryListRequest() 1778 req.meta.CopyFrom(ListRequestMetadata()) 1779 if self.parent.page_limit > 0: 1780 req.meta.limit = self.parent.page_limit 1781 if self.parent.snapshot_datetime is not None: 1782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1783 1784 req.filter = plumbing.quote_filter_args(filter, *args) 1785 1786 def generator(svc, req): 1787 tries = 0 1788 while True: 1789 t = None if deadline is None else deadline - time.time() 1790 try: 1791 plumbing_response = svc.stub.List( 1792 req, 1793 metadata=svc.parent.get_metadata( 1794 'ApprovalWorkflowStepsHistory.List', req), 1795 timeout=t) 1796 except Exception as e: 1797 if self.parent.shouldRetry(tries, e, deadline): 1798 tries += 1 1799 time.sleep( 1800 self.parent.exponentialBackoff(tries, deadline)) 1801 continue 1802 raise plumbing.convert_error_to_porcelain(e) from e 1803 tries = 0 1804 for plumbing_item in plumbing_response.history: 1805 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1806 plumbing_item) 1807 if plumbing_response.meta.next_cursor == '': 1808 break 1809 req.meta.cursor = plumbing_response.meta.next_cursor 1810 1811 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)
1772 def list(self, filter, *args, timeout=None): 1773 ''' 1774 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1775 ''' 1776 deadline = None if timeout is None else time.time() + timeout 1777 req = ApprovalWorkflowStepHistoryListRequest() 1778 req.meta.CopyFrom(ListRequestMetadata()) 1779 if self.parent.page_limit > 0: 1780 req.meta.limit = self.parent.page_limit 1781 if self.parent.snapshot_datetime is not None: 1782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1783 1784 req.filter = plumbing.quote_filter_args(filter, *args) 1785 1786 def generator(svc, req): 1787 tries = 0 1788 while True: 1789 t = None if deadline is None else deadline - time.time() 1790 try: 1791 plumbing_response = svc.stub.List( 1792 req, 1793 metadata=svc.parent.get_metadata( 1794 'ApprovalWorkflowStepsHistory.List', req), 1795 timeout=t) 1796 except Exception as e: 1797 if self.parent.shouldRetry(tries, e, deadline): 1798 tries += 1 1799 time.sleep( 1800 self.parent.exponentialBackoff(tries, deadline)) 1801 continue 1802 raise plumbing.convert_error_to_porcelain(e) from e 1803 tries = 0 1804 for plumbing_item in plumbing_response.history: 1805 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1806 plumbing_item) 1807 if plumbing_response.meta.next_cursor == '': 1808 break 1809 req.meta.cursor = plumbing_response.meta.next_cursor 1810 1811 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
1814class ApprovalWorkflows: 1815 ''' 1816 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 1817 approvers and be approved or denied. 1818 See `strongdm.models.ApprovalWorkflow`. 1819 ''' 1820 def __init__(self, channel, client): 1821 self.parent = client 1822 self.stub = ApprovalWorkflowsStub(channel) 1823 1824 def create(self, approval_workflow, timeout=None): 1825 ''' 1826 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1827 ''' 1828 deadline = None if timeout is None else time.time() + timeout 1829 req = ApprovalWorkflowCreateRequest() 1830 1831 if approval_workflow is not None: 1832 req.approval_workflow.CopyFrom( 1833 plumbing.convert_approval_workflow_to_plumbing( 1834 approval_workflow)) 1835 tries = 0 1836 plumbing_response = None 1837 while True: 1838 t = None if deadline is None else deadline - time.time() 1839 try: 1840 plumbing_response = self.stub.Create( 1841 req, 1842 metadata=self.parent.get_metadata( 1843 'ApprovalWorkflows.Create', req), 1844 timeout=t) 1845 except Exception as e: 1846 if self.parent.shouldRetry(tries, e, deadline): 1847 tries += 1 1848 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1849 continue 1850 raise plumbing.convert_error_to_porcelain(e) from e 1851 break 1852 1853 resp = models.ApprovalWorkflowCreateResponse() 1854 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1855 plumbing_response.approval_workflow) 1856 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1857 plumbing_response.rate_limit) 1858 return resp 1859 1860 def get(self, id, timeout=None): 1861 ''' 1862 Get reads one approval workflow by ID. 1863 ''' 1864 deadline = None if timeout is None else time.time() + timeout 1865 req = ApprovalWorkflowGetRequest() 1866 if self.parent.snapshot_datetime is not None: 1867 req.meta.CopyFrom(GetRequestMetadata()) 1868 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1869 1870 req.id = (id) 1871 tries = 0 1872 plumbing_response = None 1873 while True: 1874 t = None if deadline is None else deadline - time.time() 1875 try: 1876 plumbing_response = self.stub.Get( 1877 req, 1878 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1879 req), 1880 timeout=t) 1881 except Exception as e: 1882 if self.parent.shouldRetry(tries, e, deadline): 1883 tries += 1 1884 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1885 continue 1886 raise plumbing.convert_error_to_porcelain(e) from e 1887 break 1888 1889 resp = models.ApprovalWorkflowGetResponse() 1890 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1891 plumbing_response.approval_workflow) 1892 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1893 plumbing_response.meta) 1894 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1895 plumbing_response.rate_limit) 1896 return resp 1897 1898 def delete(self, id, timeout=None): 1899 ''' 1900 Delete deletes an existing approval workflow. 1901 ''' 1902 deadline = None if timeout is None else time.time() + timeout 1903 req = ApprovalWorkflowDeleteRequest() 1904 1905 req.id = (id) 1906 tries = 0 1907 plumbing_response = None 1908 while True: 1909 t = None if deadline is None else deadline - time.time() 1910 try: 1911 plumbing_response = self.stub.Delete( 1912 req, 1913 metadata=self.parent.get_metadata( 1914 'ApprovalWorkflows.Delete', req), 1915 timeout=t) 1916 except Exception as e: 1917 if self.parent.shouldRetry(tries, e, deadline): 1918 tries += 1 1919 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1920 continue 1921 raise plumbing.convert_error_to_porcelain(e) from e 1922 break 1923 1924 resp = models.ApprovalWorkflowDeleteResponse() 1925 resp.id = (plumbing_response.id) 1926 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1927 plumbing_response.rate_limit) 1928 return resp 1929 1930 def update(self, approval_workflow, timeout=None): 1931 ''' 1932 Update updates an existing approval workflow. 1933 ''' 1934 deadline = None if timeout is None else time.time() + timeout 1935 req = ApprovalWorkflowUpdateRequest() 1936 1937 if approval_workflow is not None: 1938 req.approval_workflow.CopyFrom( 1939 plumbing.convert_approval_workflow_to_plumbing( 1940 approval_workflow)) 1941 tries = 0 1942 plumbing_response = None 1943 while True: 1944 t = None if deadline is None else deadline - time.time() 1945 try: 1946 plumbing_response = self.stub.Update( 1947 req, 1948 metadata=self.parent.get_metadata( 1949 'ApprovalWorkflows.Update', req), 1950 timeout=t) 1951 except Exception as e: 1952 if self.parent.shouldRetry(tries, e, deadline): 1953 tries += 1 1954 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1955 continue 1956 raise plumbing.convert_error_to_porcelain(e) from e 1957 break 1958 1959 resp = models.ApprovalWorkflowUpdateResponse() 1960 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1961 plumbing_response.approval_workflow) 1962 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1963 plumbing_response.rate_limit) 1964 return resp 1965 1966 def list(self, filter, *args, timeout=None): 1967 ''' 1968 Lists existing approval workflows. 1969 ''' 1970 deadline = None if timeout is None else time.time() + timeout 1971 req = ApprovalWorkflowListRequest() 1972 req.meta.CopyFrom(ListRequestMetadata()) 1973 if self.parent.page_limit > 0: 1974 req.meta.limit = self.parent.page_limit 1975 if self.parent.snapshot_datetime is not None: 1976 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1977 1978 req.filter = plumbing.quote_filter_args(filter, *args) 1979 1980 def generator(svc, req): 1981 tries = 0 1982 while True: 1983 t = None if deadline is None else deadline - time.time() 1984 try: 1985 plumbing_response = svc.stub.List( 1986 req, 1987 metadata=svc.parent.get_metadata( 1988 'ApprovalWorkflows.List', req), 1989 timeout=t) 1990 except Exception as e: 1991 if self.parent.shouldRetry(tries, e, deadline): 1992 tries += 1 1993 time.sleep( 1994 self.parent.exponentialBackoff(tries, deadline)) 1995 continue 1996 raise plumbing.convert_error_to_porcelain(e) from e 1997 tries = 0 1998 for plumbing_item in plumbing_response.approval_workflows: 1999 yield plumbing.convert_approval_workflow_to_porcelain( 2000 plumbing_item) 2001 if plumbing_response.meta.next_cursor == '': 2002 break 2003 req.meta.cursor = plumbing_response.meta.next_cursor 2004 2005 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)
1824 def create(self, approval_workflow, timeout=None): 1825 ''' 1826 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1827 ''' 1828 deadline = None if timeout is None else time.time() + timeout 1829 req = ApprovalWorkflowCreateRequest() 1830 1831 if approval_workflow is not None: 1832 req.approval_workflow.CopyFrom( 1833 plumbing.convert_approval_workflow_to_plumbing( 1834 approval_workflow)) 1835 tries = 0 1836 plumbing_response = None 1837 while True: 1838 t = None if deadline is None else deadline - time.time() 1839 try: 1840 plumbing_response = self.stub.Create( 1841 req, 1842 metadata=self.parent.get_metadata( 1843 'ApprovalWorkflows.Create', req), 1844 timeout=t) 1845 except Exception as e: 1846 if self.parent.shouldRetry(tries, e, deadline): 1847 tries += 1 1848 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1849 continue 1850 raise plumbing.convert_error_to_porcelain(e) from e 1851 break 1852 1853 resp = models.ApprovalWorkflowCreateResponse() 1854 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1855 plumbing_response.approval_workflow) 1856 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1857 plumbing_response.rate_limit) 1858 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)
1860 def get(self, id, timeout=None): 1861 ''' 1862 Get reads one approval workflow by ID. 1863 ''' 1864 deadline = None if timeout is None else time.time() + timeout 1865 req = ApprovalWorkflowGetRequest() 1866 if self.parent.snapshot_datetime is not None: 1867 req.meta.CopyFrom(GetRequestMetadata()) 1868 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1869 1870 req.id = (id) 1871 tries = 0 1872 plumbing_response = None 1873 while True: 1874 t = None if deadline is None else deadline - time.time() 1875 try: 1876 plumbing_response = self.stub.Get( 1877 req, 1878 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1879 req), 1880 timeout=t) 1881 except Exception as e: 1882 if self.parent.shouldRetry(tries, e, deadline): 1883 tries += 1 1884 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1885 continue 1886 raise plumbing.convert_error_to_porcelain(e) from e 1887 break 1888 1889 resp = models.ApprovalWorkflowGetResponse() 1890 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1891 plumbing_response.approval_workflow) 1892 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1893 plumbing_response.meta) 1894 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1895 plumbing_response.rate_limit) 1896 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
1898 def delete(self, id, timeout=None): 1899 ''' 1900 Delete deletes an existing approval workflow. 1901 ''' 1902 deadline = None if timeout is None else time.time() + timeout 1903 req = ApprovalWorkflowDeleteRequest() 1904 1905 req.id = (id) 1906 tries = 0 1907 plumbing_response = None 1908 while True: 1909 t = None if deadline is None else deadline - time.time() 1910 try: 1911 plumbing_response = self.stub.Delete( 1912 req, 1913 metadata=self.parent.get_metadata( 1914 'ApprovalWorkflows.Delete', req), 1915 timeout=t) 1916 except Exception as e: 1917 if self.parent.shouldRetry(tries, e, deadline): 1918 tries += 1 1919 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1920 continue 1921 raise plumbing.convert_error_to_porcelain(e) from e 1922 break 1923 1924 resp = models.ApprovalWorkflowDeleteResponse() 1925 resp.id = (plumbing_response.id) 1926 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1927 plumbing_response.rate_limit) 1928 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
1930 def update(self, approval_workflow, timeout=None): 1931 ''' 1932 Update updates an existing approval workflow. 1933 ''' 1934 deadline = None if timeout is None else time.time() + timeout 1935 req = ApprovalWorkflowUpdateRequest() 1936 1937 if approval_workflow is not None: 1938 req.approval_workflow.CopyFrom( 1939 plumbing.convert_approval_workflow_to_plumbing( 1940 approval_workflow)) 1941 tries = 0 1942 plumbing_response = None 1943 while True: 1944 t = None if deadline is None else deadline - time.time() 1945 try: 1946 plumbing_response = self.stub.Update( 1947 req, 1948 metadata=self.parent.get_metadata( 1949 'ApprovalWorkflows.Update', req), 1950 timeout=t) 1951 except Exception as e: 1952 if self.parent.shouldRetry(tries, e, deadline): 1953 tries += 1 1954 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1955 continue 1956 raise plumbing.convert_error_to_porcelain(e) from e 1957 break 1958 1959 resp = models.ApprovalWorkflowUpdateResponse() 1960 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1961 plumbing_response.approval_workflow) 1962 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1963 plumbing_response.rate_limit) 1964 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
1966 def list(self, filter, *args, timeout=None): 1967 ''' 1968 Lists existing approval workflows. 1969 ''' 1970 deadline = None if timeout is None else time.time() + timeout 1971 req = ApprovalWorkflowListRequest() 1972 req.meta.CopyFrom(ListRequestMetadata()) 1973 if self.parent.page_limit > 0: 1974 req.meta.limit = self.parent.page_limit 1975 if self.parent.snapshot_datetime is not None: 1976 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1977 1978 req.filter = plumbing.quote_filter_args(filter, *args) 1979 1980 def generator(svc, req): 1981 tries = 0 1982 while True: 1983 t = None if deadline is None else deadline - time.time() 1984 try: 1985 plumbing_response = svc.stub.List( 1986 req, 1987 metadata=svc.parent.get_metadata( 1988 'ApprovalWorkflows.List', req), 1989 timeout=t) 1990 except Exception as e: 1991 if self.parent.shouldRetry(tries, e, deadline): 1992 tries += 1 1993 time.sleep( 1994 self.parent.exponentialBackoff(tries, deadline)) 1995 continue 1996 raise plumbing.convert_error_to_porcelain(e) from e 1997 tries = 0 1998 for plumbing_item in plumbing_response.approval_workflows: 1999 yield plumbing.convert_approval_workflow_to_porcelain( 2000 plumbing_item) 2001 if plumbing_response.meta.next_cursor == '': 2002 break 2003 req.meta.cursor = plumbing_response.meta.next_cursor 2004 2005 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2008class SnapshotApprovalWorkflows: 2009 ''' 2010 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2011 service for historical queries. 2012 ''' 2013 def __init__(self, approval_workflows): 2014 self.approval_workflows = approval_workflows 2015 2016 def get(self, id, timeout=None): 2017 ''' 2018 Get reads one approval workflow by ID. 2019 ''' 2020 return self.approval_workflows.get(id, timeout=timeout) 2021 2022 def list(self, filter, *args, timeout=None): 2023 ''' 2024 Lists existing approval workflows. 2025 ''' 2026 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2029class ApprovalWorkflowsHistory: 2030 ''' 2031 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2032 See `strongdm.models.ApprovalWorkflowHistory`. 2033 ''' 2034 def __init__(self, channel, client): 2035 self.parent = client 2036 self.stub = ApprovalWorkflowsHistoryStub(channel) 2037 2038 def list(self, filter, *args, timeout=None): 2039 ''' 2040 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2041 ''' 2042 deadline = None if timeout is None else time.time() + timeout 2043 req = ApprovalWorkflowHistoryListRequest() 2044 req.meta.CopyFrom(ListRequestMetadata()) 2045 if self.parent.page_limit > 0: 2046 req.meta.limit = self.parent.page_limit 2047 if self.parent.snapshot_datetime is not None: 2048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2049 2050 req.filter = plumbing.quote_filter_args(filter, *args) 2051 2052 def generator(svc, req): 2053 tries = 0 2054 while True: 2055 t = None if deadline is None else deadline - time.time() 2056 try: 2057 plumbing_response = svc.stub.List( 2058 req, 2059 metadata=svc.parent.get_metadata( 2060 'ApprovalWorkflowsHistory.List', req), 2061 timeout=t) 2062 except Exception as e: 2063 if self.parent.shouldRetry(tries, e, deadline): 2064 tries += 1 2065 time.sleep( 2066 self.parent.exponentialBackoff(tries, deadline)) 2067 continue 2068 raise plumbing.convert_error_to_porcelain(e) from e 2069 tries = 0 2070 for plumbing_item in plumbing_response.history: 2071 yield plumbing.convert_approval_workflow_history_to_porcelain( 2072 plumbing_item) 2073 if plumbing_response.meta.next_cursor == '': 2074 break 2075 req.meta.cursor = plumbing_response.meta.next_cursor 2076 2077 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)
2038 def list(self, filter, *args, timeout=None): 2039 ''' 2040 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2041 ''' 2042 deadline = None if timeout is None else time.time() + timeout 2043 req = ApprovalWorkflowHistoryListRequest() 2044 req.meta.CopyFrom(ListRequestMetadata()) 2045 if self.parent.page_limit > 0: 2046 req.meta.limit = self.parent.page_limit 2047 if self.parent.snapshot_datetime is not None: 2048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2049 2050 req.filter = plumbing.quote_filter_args(filter, *args) 2051 2052 def generator(svc, req): 2053 tries = 0 2054 while True: 2055 t = None if deadline is None else deadline - time.time() 2056 try: 2057 plumbing_response = svc.stub.List( 2058 req, 2059 metadata=svc.parent.get_metadata( 2060 'ApprovalWorkflowsHistory.List', req), 2061 timeout=t) 2062 except Exception as e: 2063 if self.parent.shouldRetry(tries, e, deadline): 2064 tries += 1 2065 time.sleep( 2066 self.parent.exponentialBackoff(tries, deadline)) 2067 continue 2068 raise plumbing.convert_error_to_porcelain(e) from e 2069 tries = 0 2070 for plumbing_item in plumbing_response.history: 2071 yield plumbing.convert_approval_workflow_history_to_porcelain( 2072 plumbing_item) 2073 if plumbing_response.meta.next_cursor == '': 2074 break 2075 req.meta.cursor = plumbing_response.meta.next_cursor 2076 2077 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2080class ControlPanel: 2081 ''' 2082 ControlPanel contains all administrative controls. 2083 ''' 2084 def __init__(self, channel, client): 2085 self.parent = client 2086 self.stub = ControlPanelStub(channel) 2087 2088 def get_sshca_public_key(self, timeout=None): 2089 ''' 2090 GetSSHCAPublicKey retrieves the SSH CA public key. 2091 ''' 2092 deadline = None if timeout is None else time.time() + timeout 2093 req = ControlPanelGetSSHCAPublicKeyRequest() 2094 2095 tries = 0 2096 plumbing_response = None 2097 while True: 2098 t = None if deadline is None else deadline - time.time() 2099 try: 2100 plumbing_response = self.stub.GetSSHCAPublicKey( 2101 req, 2102 metadata=self.parent.get_metadata( 2103 'ControlPanel.GetSSHCAPublicKey', req), 2104 timeout=t) 2105 except Exception as e: 2106 if self.parent.shouldRetry(tries, e, deadline): 2107 tries += 1 2108 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2109 continue 2110 raise plumbing.convert_error_to_porcelain(e) from e 2111 break 2112 2113 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2114 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2115 plumbing_response.meta) 2116 resp.public_key = (plumbing_response.public_key) 2117 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2118 plumbing_response.rate_limit) 2119 return resp 2120 2121 def get_rdpca_public_key(self, timeout=None): 2122 ''' 2123 GetRDPCAPublicKey retrieves the RDP CA public key. 2124 ''' 2125 deadline = None if timeout is None else time.time() + timeout 2126 req = ControlPanelGetRDPCAPublicKeyRequest() 2127 2128 tries = 0 2129 plumbing_response = None 2130 while True: 2131 t = None if deadline is None else deadline - time.time() 2132 try: 2133 plumbing_response = self.stub.GetRDPCAPublicKey( 2134 req, 2135 metadata=self.parent.get_metadata( 2136 'ControlPanel.GetRDPCAPublicKey', req), 2137 timeout=t) 2138 except Exception as e: 2139 if self.parent.shouldRetry(tries, e, deadline): 2140 tries += 1 2141 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2142 continue 2143 raise plumbing.convert_error_to_porcelain(e) from e 2144 break 2145 2146 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2147 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2148 plumbing_response.meta) 2149 resp.public_key = (plumbing_response.public_key) 2150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2151 plumbing_response.rate_limit) 2152 return resp 2153 2154 def verify_jwt(self, token, timeout=None): 2155 ''' 2156 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2157 ''' 2158 deadline = None if timeout is None else time.time() + timeout 2159 req = ControlPanelVerifyJWTRequest() 2160 2161 req.token = (token) 2162 tries = 0 2163 plumbing_response = None 2164 while True: 2165 t = None if deadline is None else deadline - time.time() 2166 try: 2167 plumbing_response = self.stub.VerifyJWT( 2168 req, 2169 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2170 req), 2171 timeout=t) 2172 except Exception as e: 2173 if self.parent.shouldRetry(tries, e, deadline): 2174 tries += 1 2175 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2176 continue 2177 raise plumbing.convert_error_to_porcelain(e) from e 2178 break 2179 2180 resp = models.ControlPanelVerifyJWTResponse() 2181 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2182 plumbing_response.meta) 2183 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2184 plumbing_response.rate_limit) 2185 resp.valid = (plumbing_response.valid) 2186 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2088 def get_sshca_public_key(self, timeout=None): 2089 ''' 2090 GetSSHCAPublicKey retrieves the SSH CA public key. 2091 ''' 2092 deadline = None if timeout is None else time.time() + timeout 2093 req = ControlPanelGetSSHCAPublicKeyRequest() 2094 2095 tries = 0 2096 plumbing_response = None 2097 while True: 2098 t = None if deadline is None else deadline - time.time() 2099 try: 2100 plumbing_response = self.stub.GetSSHCAPublicKey( 2101 req, 2102 metadata=self.parent.get_metadata( 2103 'ControlPanel.GetSSHCAPublicKey', req), 2104 timeout=t) 2105 except Exception as e: 2106 if self.parent.shouldRetry(tries, e, deadline): 2107 tries += 1 2108 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2109 continue 2110 raise plumbing.convert_error_to_porcelain(e) from e 2111 break 2112 2113 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2114 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2115 plumbing_response.meta) 2116 resp.public_key = (plumbing_response.public_key) 2117 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2118 plumbing_response.rate_limit) 2119 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2121 def get_rdpca_public_key(self, timeout=None): 2122 ''' 2123 GetRDPCAPublicKey retrieves the RDP CA public key. 2124 ''' 2125 deadline = None if timeout is None else time.time() + timeout 2126 req = ControlPanelGetRDPCAPublicKeyRequest() 2127 2128 tries = 0 2129 plumbing_response = None 2130 while True: 2131 t = None if deadline is None else deadline - time.time() 2132 try: 2133 plumbing_response = self.stub.GetRDPCAPublicKey( 2134 req, 2135 metadata=self.parent.get_metadata( 2136 'ControlPanel.GetRDPCAPublicKey', req), 2137 timeout=t) 2138 except Exception as e: 2139 if self.parent.shouldRetry(tries, e, deadline): 2140 tries += 1 2141 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2142 continue 2143 raise plumbing.convert_error_to_porcelain(e) from e 2144 break 2145 2146 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2147 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2148 plumbing_response.meta) 2149 resp.public_key = (plumbing_response.public_key) 2150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2151 plumbing_response.rate_limit) 2152 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
verify_jwt(self, token, timeout=None)
2154 def verify_jwt(self, token, timeout=None): 2155 ''' 2156 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2157 ''' 2158 deadline = None if timeout is None else time.time() + timeout 2159 req = ControlPanelVerifyJWTRequest() 2160 2161 req.token = (token) 2162 tries = 0 2163 plumbing_response = None 2164 while True: 2165 t = None if deadline is None else deadline - time.time() 2166 try: 2167 plumbing_response = self.stub.VerifyJWT( 2168 req, 2169 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2170 req), 2171 timeout=t) 2172 except Exception as e: 2173 if self.parent.shouldRetry(tries, e, deadline): 2174 tries += 1 2175 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2176 continue 2177 raise plumbing.convert_error_to_porcelain(e) from e 2178 break 2179 2180 resp = models.ControlPanelVerifyJWTResponse() 2181 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2182 plumbing_response.meta) 2183 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2184 plumbing_response.rate_limit) 2185 resp.valid = (plumbing_response.valid) 2186 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
HealthChecks:
2189class HealthChecks: 2190 ''' 2191 HealthChecks lists the last healthcheck between each node and resource. 2192 Note the unconventional capitalization here is to prevent having a collision with GRPC 2193 See `strongdm.models.Healthcheck`. 2194 ''' 2195 def __init__(self, channel, client): 2196 self.parent = client 2197 self.stub = HealthChecksStub(channel) 2198 2199 def list(self, filter, *args, timeout=None): 2200 ''' 2201 List gets a list of Healthchecks matching a given set of criteria. 2202 ''' 2203 deadline = None if timeout is None else time.time() + timeout 2204 req = HealthcheckListRequest() 2205 req.meta.CopyFrom(ListRequestMetadata()) 2206 if self.parent.page_limit > 0: 2207 req.meta.limit = self.parent.page_limit 2208 if self.parent.snapshot_datetime is not None: 2209 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2210 2211 req.filter = plumbing.quote_filter_args(filter, *args) 2212 2213 def generator(svc, req): 2214 tries = 0 2215 while True: 2216 t = None if deadline is None else deadline - time.time() 2217 try: 2218 plumbing_response = svc.stub.List( 2219 req, 2220 metadata=svc.parent.get_metadata( 2221 'HealthChecks.List', req), 2222 timeout=t) 2223 except Exception as e: 2224 if self.parent.shouldRetry(tries, e, deadline): 2225 tries += 1 2226 time.sleep( 2227 self.parent.exponentialBackoff(tries, deadline)) 2228 continue 2229 raise plumbing.convert_error_to_porcelain(e) from e 2230 tries = 0 2231 for plumbing_item in plumbing_response.healthchecks: 2232 yield plumbing.convert_healthcheck_to_porcelain( 2233 plumbing_item) 2234 if plumbing_response.meta.next_cursor == '': 2235 break 2236 req.meta.cursor = plumbing_response.meta.next_cursor 2237 2238 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)
2199 def list(self, filter, *args, timeout=None): 2200 ''' 2201 List gets a list of Healthchecks matching a given set of criteria. 2202 ''' 2203 deadline = None if timeout is None else time.time() + timeout 2204 req = HealthcheckListRequest() 2205 req.meta.CopyFrom(ListRequestMetadata()) 2206 if self.parent.page_limit > 0: 2207 req.meta.limit = self.parent.page_limit 2208 if self.parent.snapshot_datetime is not None: 2209 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2210 2211 req.filter = plumbing.quote_filter_args(filter, *args) 2212 2213 def generator(svc, req): 2214 tries = 0 2215 while True: 2216 t = None if deadline is None else deadline - time.time() 2217 try: 2218 plumbing_response = svc.stub.List( 2219 req, 2220 metadata=svc.parent.get_metadata( 2221 'HealthChecks.List', req), 2222 timeout=t) 2223 except Exception as e: 2224 if self.parent.shouldRetry(tries, e, deadline): 2225 tries += 1 2226 time.sleep( 2227 self.parent.exponentialBackoff(tries, deadline)) 2228 continue 2229 raise plumbing.convert_error_to_porcelain(e) from e 2230 tries = 0 2231 for plumbing_item in plumbing_response.healthchecks: 2232 yield plumbing.convert_healthcheck_to_porcelain( 2233 plumbing_item) 2234 if plumbing_response.meta.next_cursor == '': 2235 break 2236 req.meta.cursor = plumbing_response.meta.next_cursor 2237 2238 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
2241class IdentityAliases: 2242 ''' 2243 IdentityAliases assign an alias to an account within an IdentitySet. 2244 The alias is used as the username when connecting to a identity supported resource. 2245 See `strongdm.models.IdentityAlias`. 2246 ''' 2247 def __init__(self, channel, client): 2248 self.parent = client 2249 self.stub = IdentityAliasesStub(channel) 2250 2251 def create(self, identity_alias, timeout=None): 2252 ''' 2253 Create registers a new IdentityAlias. 2254 ''' 2255 deadline = None if timeout is None else time.time() + timeout 2256 req = IdentityAliasCreateRequest() 2257 2258 if identity_alias is not None: 2259 req.identity_alias.CopyFrom( 2260 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2261 tries = 0 2262 plumbing_response = None 2263 while True: 2264 t = None if deadline is None else deadline - time.time() 2265 try: 2266 plumbing_response = self.stub.Create( 2267 req, 2268 metadata=self.parent.get_metadata('IdentityAliases.Create', 2269 req), 2270 timeout=t) 2271 except Exception as e: 2272 if self.parent.shouldRetry(tries, e, deadline): 2273 tries += 1 2274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2275 continue 2276 raise plumbing.convert_error_to_porcelain(e) from e 2277 break 2278 2279 resp = models.IdentityAliasCreateResponse() 2280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2281 plumbing_response.identity_alias) 2282 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2283 plumbing_response.meta) 2284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2285 plumbing_response.rate_limit) 2286 return resp 2287 2288 def get(self, id, timeout=None): 2289 ''' 2290 Get reads one IdentityAlias by ID. 2291 ''' 2292 deadline = None if timeout is None else time.time() + timeout 2293 req = IdentityAliasGetRequest() 2294 if self.parent.snapshot_datetime is not None: 2295 req.meta.CopyFrom(GetRequestMetadata()) 2296 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2297 2298 req.id = (id) 2299 tries = 0 2300 plumbing_response = None 2301 while True: 2302 t = None if deadline is None else deadline - time.time() 2303 try: 2304 plumbing_response = self.stub.Get( 2305 req, 2306 metadata=self.parent.get_metadata('IdentityAliases.Get', 2307 req), 2308 timeout=t) 2309 except Exception as e: 2310 if self.parent.shouldRetry(tries, e, deadline): 2311 tries += 1 2312 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2313 continue 2314 raise plumbing.convert_error_to_porcelain(e) from e 2315 break 2316 2317 resp = models.IdentityAliasGetResponse() 2318 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2319 plumbing_response.identity_alias) 2320 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2321 plumbing_response.meta) 2322 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2323 plumbing_response.rate_limit) 2324 return resp 2325 2326 def update(self, identity_alias, timeout=None): 2327 ''' 2328 Update replaces all the fields of a IdentityAlias by ID. 2329 ''' 2330 deadline = None if timeout is None else time.time() + timeout 2331 req = IdentityAliasUpdateRequest() 2332 2333 if identity_alias is not None: 2334 req.identity_alias.CopyFrom( 2335 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2336 tries = 0 2337 plumbing_response = None 2338 while True: 2339 t = None if deadline is None else deadline - time.time() 2340 try: 2341 plumbing_response = self.stub.Update( 2342 req, 2343 metadata=self.parent.get_metadata('IdentityAliases.Update', 2344 req), 2345 timeout=t) 2346 except Exception as e: 2347 if self.parent.shouldRetry(tries, e, deadline): 2348 tries += 1 2349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2350 continue 2351 raise plumbing.convert_error_to_porcelain(e) from e 2352 break 2353 2354 resp = models.IdentityAliasUpdateResponse() 2355 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2356 plumbing_response.identity_alias) 2357 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2358 plumbing_response.meta) 2359 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2360 plumbing_response.rate_limit) 2361 return resp 2362 2363 def delete(self, id, timeout=None): 2364 ''' 2365 Delete removes a IdentityAlias by ID. 2366 ''' 2367 deadline = None if timeout is None else time.time() + timeout 2368 req = IdentityAliasDeleteRequest() 2369 2370 req.id = (id) 2371 tries = 0 2372 plumbing_response = None 2373 while True: 2374 t = None if deadline is None else deadline - time.time() 2375 try: 2376 plumbing_response = self.stub.Delete( 2377 req, 2378 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2379 req), 2380 timeout=t) 2381 except Exception as e: 2382 if self.parent.shouldRetry(tries, e, deadline): 2383 tries += 1 2384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2385 continue 2386 raise plumbing.convert_error_to_porcelain(e) from e 2387 break 2388 2389 resp = models.IdentityAliasDeleteResponse() 2390 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2391 plumbing_response.meta) 2392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2393 plumbing_response.rate_limit) 2394 return resp 2395 2396 def list(self, filter, *args, timeout=None): 2397 ''' 2398 List gets a list of IdentityAliases matching a given set of criteria. 2399 ''' 2400 deadline = None if timeout is None else time.time() + timeout 2401 req = IdentityAliasListRequest() 2402 req.meta.CopyFrom(ListRequestMetadata()) 2403 if self.parent.page_limit > 0: 2404 req.meta.limit = self.parent.page_limit 2405 if self.parent.snapshot_datetime is not None: 2406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2407 2408 req.filter = plumbing.quote_filter_args(filter, *args) 2409 2410 def generator(svc, req): 2411 tries = 0 2412 while True: 2413 t = None if deadline is None else deadline - time.time() 2414 try: 2415 plumbing_response = svc.stub.List( 2416 req, 2417 metadata=svc.parent.get_metadata( 2418 'IdentityAliases.List', req), 2419 timeout=t) 2420 except Exception as e: 2421 if self.parent.shouldRetry(tries, e, deadline): 2422 tries += 1 2423 time.sleep( 2424 self.parent.exponentialBackoff(tries, deadline)) 2425 continue 2426 raise plumbing.convert_error_to_porcelain(e) from e 2427 tries = 0 2428 for plumbing_item in plumbing_response.identity_aliases: 2429 yield plumbing.convert_identity_alias_to_porcelain( 2430 plumbing_item) 2431 if plumbing_response.meta.next_cursor == '': 2432 break 2433 req.meta.cursor = plumbing_response.meta.next_cursor 2434 2435 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)
2251 def create(self, identity_alias, timeout=None): 2252 ''' 2253 Create registers a new IdentityAlias. 2254 ''' 2255 deadline = None if timeout is None else time.time() + timeout 2256 req = IdentityAliasCreateRequest() 2257 2258 if identity_alias is not None: 2259 req.identity_alias.CopyFrom( 2260 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2261 tries = 0 2262 plumbing_response = None 2263 while True: 2264 t = None if deadline is None else deadline - time.time() 2265 try: 2266 plumbing_response = self.stub.Create( 2267 req, 2268 metadata=self.parent.get_metadata('IdentityAliases.Create', 2269 req), 2270 timeout=t) 2271 except Exception as e: 2272 if self.parent.shouldRetry(tries, e, deadline): 2273 tries += 1 2274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2275 continue 2276 raise plumbing.convert_error_to_porcelain(e) from e 2277 break 2278 2279 resp = models.IdentityAliasCreateResponse() 2280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2281 plumbing_response.identity_alias) 2282 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2283 plumbing_response.meta) 2284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2285 plumbing_response.rate_limit) 2286 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
2288 def get(self, id, timeout=None): 2289 ''' 2290 Get reads one IdentityAlias by ID. 2291 ''' 2292 deadline = None if timeout is None else time.time() + timeout 2293 req = IdentityAliasGetRequest() 2294 if self.parent.snapshot_datetime is not None: 2295 req.meta.CopyFrom(GetRequestMetadata()) 2296 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2297 2298 req.id = (id) 2299 tries = 0 2300 plumbing_response = None 2301 while True: 2302 t = None if deadline is None else deadline - time.time() 2303 try: 2304 plumbing_response = self.stub.Get( 2305 req, 2306 metadata=self.parent.get_metadata('IdentityAliases.Get', 2307 req), 2308 timeout=t) 2309 except Exception as e: 2310 if self.parent.shouldRetry(tries, e, deadline): 2311 tries += 1 2312 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2313 continue 2314 raise plumbing.convert_error_to_porcelain(e) from e 2315 break 2316 2317 resp = models.IdentityAliasGetResponse() 2318 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2319 plumbing_response.identity_alias) 2320 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2321 plumbing_response.meta) 2322 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2323 plumbing_response.rate_limit) 2324 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
2326 def update(self, identity_alias, timeout=None): 2327 ''' 2328 Update replaces all the fields of a IdentityAlias by ID. 2329 ''' 2330 deadline = None if timeout is None else time.time() + timeout 2331 req = IdentityAliasUpdateRequest() 2332 2333 if identity_alias is not None: 2334 req.identity_alias.CopyFrom( 2335 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2336 tries = 0 2337 plumbing_response = None 2338 while True: 2339 t = None if deadline is None else deadline - time.time() 2340 try: 2341 plumbing_response = self.stub.Update( 2342 req, 2343 metadata=self.parent.get_metadata('IdentityAliases.Update', 2344 req), 2345 timeout=t) 2346 except Exception as e: 2347 if self.parent.shouldRetry(tries, e, deadline): 2348 tries += 1 2349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2350 continue 2351 raise plumbing.convert_error_to_porcelain(e) from e 2352 break 2353 2354 resp = models.IdentityAliasUpdateResponse() 2355 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2356 plumbing_response.identity_alias) 2357 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2358 plumbing_response.meta) 2359 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2360 plumbing_response.rate_limit) 2361 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
2363 def delete(self, id, timeout=None): 2364 ''' 2365 Delete removes a IdentityAlias by ID. 2366 ''' 2367 deadline = None if timeout is None else time.time() + timeout 2368 req = IdentityAliasDeleteRequest() 2369 2370 req.id = (id) 2371 tries = 0 2372 plumbing_response = None 2373 while True: 2374 t = None if deadline is None else deadline - time.time() 2375 try: 2376 plumbing_response = self.stub.Delete( 2377 req, 2378 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2379 req), 2380 timeout=t) 2381 except Exception as e: 2382 if self.parent.shouldRetry(tries, e, deadline): 2383 tries += 1 2384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2385 continue 2386 raise plumbing.convert_error_to_porcelain(e) from e 2387 break 2388 2389 resp = models.IdentityAliasDeleteResponse() 2390 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2391 plumbing_response.meta) 2392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2393 plumbing_response.rate_limit) 2394 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2396 def list(self, filter, *args, timeout=None): 2397 ''' 2398 List gets a list of IdentityAliases matching a given set of criteria. 2399 ''' 2400 deadline = None if timeout is None else time.time() + timeout 2401 req = IdentityAliasListRequest() 2402 req.meta.CopyFrom(ListRequestMetadata()) 2403 if self.parent.page_limit > 0: 2404 req.meta.limit = self.parent.page_limit 2405 if self.parent.snapshot_datetime is not None: 2406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2407 2408 req.filter = plumbing.quote_filter_args(filter, *args) 2409 2410 def generator(svc, req): 2411 tries = 0 2412 while True: 2413 t = None if deadline is None else deadline - time.time() 2414 try: 2415 plumbing_response = svc.stub.List( 2416 req, 2417 metadata=svc.parent.get_metadata( 2418 'IdentityAliases.List', req), 2419 timeout=t) 2420 except Exception as e: 2421 if self.parent.shouldRetry(tries, e, deadline): 2422 tries += 1 2423 time.sleep( 2424 self.parent.exponentialBackoff(tries, deadline)) 2425 continue 2426 raise plumbing.convert_error_to_porcelain(e) from e 2427 tries = 0 2428 for plumbing_item in plumbing_response.identity_aliases: 2429 yield plumbing.convert_identity_alias_to_porcelain( 2430 plumbing_item) 2431 if plumbing_response.meta.next_cursor == '': 2432 break 2433 req.meta.cursor = plumbing_response.meta.next_cursor 2434 2435 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
2438class SnapshotIdentityAliases: 2439 ''' 2440 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2441 service for historical queries. 2442 ''' 2443 def __init__(self, identity_aliases): 2444 self.identity_aliases = identity_aliases 2445 2446 def get(self, id, timeout=None): 2447 ''' 2448 Get reads one IdentityAlias by ID. 2449 ''' 2450 return self.identity_aliases.get(id, timeout=timeout) 2451 2452 def list(self, filter, *args, timeout=None): 2453 ''' 2454 List gets a list of IdentityAliases matching a given set of criteria. 2455 ''' 2456 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)
2446 def get(self, id, timeout=None): 2447 ''' 2448 Get reads one IdentityAlias by ID. 2449 ''' 2450 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2452 def list(self, filter, *args, timeout=None): 2453 ''' 2454 List gets a list of IdentityAliases matching a given set of criteria. 2455 ''' 2456 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
2459class IdentityAliasesHistory: 2460 ''' 2461 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2462 See `strongdm.models.IdentityAliasHistory`. 2463 ''' 2464 def __init__(self, channel, client): 2465 self.parent = client 2466 self.stub = IdentityAliasesHistoryStub(channel) 2467 2468 def list(self, filter, *args, timeout=None): 2469 ''' 2470 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2471 ''' 2472 deadline = None if timeout is None else time.time() + timeout 2473 req = IdentityAliasHistoryListRequest() 2474 req.meta.CopyFrom(ListRequestMetadata()) 2475 if self.parent.page_limit > 0: 2476 req.meta.limit = self.parent.page_limit 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2479 2480 req.filter = plumbing.quote_filter_args(filter, *args) 2481 2482 def generator(svc, req): 2483 tries = 0 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = svc.stub.List( 2488 req, 2489 metadata=svc.parent.get_metadata( 2490 'IdentityAliasesHistory.List', req), 2491 timeout=t) 2492 except Exception as e: 2493 if self.parent.shouldRetry(tries, e, deadline): 2494 tries += 1 2495 time.sleep( 2496 self.parent.exponentialBackoff(tries, deadline)) 2497 continue 2498 raise plumbing.convert_error_to_porcelain(e) from e 2499 tries = 0 2500 for plumbing_item in plumbing_response.history: 2501 yield plumbing.convert_identity_alias_history_to_porcelain( 2502 plumbing_item) 2503 if plumbing_response.meta.next_cursor == '': 2504 break 2505 req.meta.cursor = plumbing_response.meta.next_cursor 2506 2507 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)
2468 def list(self, filter, *args, timeout=None): 2469 ''' 2470 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2471 ''' 2472 deadline = None if timeout is None else time.time() + timeout 2473 req = IdentityAliasHistoryListRequest() 2474 req.meta.CopyFrom(ListRequestMetadata()) 2475 if self.parent.page_limit > 0: 2476 req.meta.limit = self.parent.page_limit 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2479 2480 req.filter = plumbing.quote_filter_args(filter, *args) 2481 2482 def generator(svc, req): 2483 tries = 0 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = svc.stub.List( 2488 req, 2489 metadata=svc.parent.get_metadata( 2490 'IdentityAliasesHistory.List', req), 2491 timeout=t) 2492 except Exception as e: 2493 if self.parent.shouldRetry(tries, e, deadline): 2494 tries += 1 2495 time.sleep( 2496 self.parent.exponentialBackoff(tries, deadline)) 2497 continue 2498 raise plumbing.convert_error_to_porcelain(e) from e 2499 tries = 0 2500 for plumbing_item in plumbing_response.history: 2501 yield plumbing.convert_identity_alias_history_to_porcelain( 2502 plumbing_item) 2503 if plumbing_response.meta.next_cursor == '': 2504 break 2505 req.meta.cursor = plumbing_response.meta.next_cursor 2506 2507 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
2510class IdentitySets: 2511 ''' 2512 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2513 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2514 See `strongdm.models.IdentitySet`. 2515 ''' 2516 def __init__(self, channel, client): 2517 self.parent = client 2518 self.stub = IdentitySetsStub(channel) 2519 2520 def create(self, identity_set, timeout=None): 2521 ''' 2522 Create registers a new IdentitySet. 2523 ''' 2524 deadline = None if timeout is None else time.time() + timeout 2525 req = IdentitySetCreateRequest() 2526 2527 if identity_set is not None: 2528 req.identity_set.CopyFrom( 2529 plumbing.convert_identity_set_to_plumbing(identity_set)) 2530 tries = 0 2531 plumbing_response = None 2532 while True: 2533 t = None if deadline is None else deadline - time.time() 2534 try: 2535 plumbing_response = self.stub.Create( 2536 req, 2537 metadata=self.parent.get_metadata('IdentitySets.Create', 2538 req), 2539 timeout=t) 2540 except Exception as e: 2541 if self.parent.shouldRetry(tries, e, deadline): 2542 tries += 1 2543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2544 continue 2545 raise plumbing.convert_error_to_porcelain(e) from e 2546 break 2547 2548 resp = models.IdentitySetCreateResponse() 2549 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2550 plumbing_response.identity_set) 2551 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2552 plumbing_response.meta) 2553 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2554 plumbing_response.rate_limit) 2555 return resp 2556 2557 def get(self, id, timeout=None): 2558 ''' 2559 Get reads one IdentitySet by ID. 2560 ''' 2561 deadline = None if timeout is None else time.time() + timeout 2562 req = IdentitySetGetRequest() 2563 if self.parent.snapshot_datetime is not None: 2564 req.meta.CopyFrom(GetRequestMetadata()) 2565 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2566 2567 req.id = (id) 2568 tries = 0 2569 plumbing_response = None 2570 while True: 2571 t = None if deadline is None else deadline - time.time() 2572 try: 2573 plumbing_response = self.stub.Get( 2574 req, 2575 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2576 timeout=t) 2577 except Exception as e: 2578 if self.parent.shouldRetry(tries, e, deadline): 2579 tries += 1 2580 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2581 continue 2582 raise plumbing.convert_error_to_porcelain(e) from e 2583 break 2584 2585 resp = models.IdentitySetGetResponse() 2586 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2587 plumbing_response.identity_set) 2588 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2589 plumbing_response.meta) 2590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2591 plumbing_response.rate_limit) 2592 return resp 2593 2594 def update(self, identity_set, timeout=None): 2595 ''' 2596 Update replaces all the fields of a IdentitySet by ID. 2597 ''' 2598 deadline = None if timeout is None else time.time() + timeout 2599 req = IdentitySetUpdateRequest() 2600 2601 if identity_set is not None: 2602 req.identity_set.CopyFrom( 2603 plumbing.convert_identity_set_to_plumbing(identity_set)) 2604 tries = 0 2605 plumbing_response = None 2606 while True: 2607 t = None if deadline is None else deadline - time.time() 2608 try: 2609 plumbing_response = self.stub.Update( 2610 req, 2611 metadata=self.parent.get_metadata('IdentitySets.Update', 2612 req), 2613 timeout=t) 2614 except Exception as e: 2615 if self.parent.shouldRetry(tries, e, deadline): 2616 tries += 1 2617 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2618 continue 2619 raise plumbing.convert_error_to_porcelain(e) from e 2620 break 2621 2622 resp = models.IdentitySetUpdateResponse() 2623 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2624 plumbing_response.identity_set) 2625 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2626 plumbing_response.meta) 2627 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2628 plumbing_response.rate_limit) 2629 return resp 2630 2631 def delete(self, id, timeout=None): 2632 ''' 2633 Delete removes a IdentitySet by ID. 2634 ''' 2635 deadline = None if timeout is None else time.time() + timeout 2636 req = IdentitySetDeleteRequest() 2637 2638 req.id = (id) 2639 tries = 0 2640 plumbing_response = None 2641 while True: 2642 t = None if deadline is None else deadline - time.time() 2643 try: 2644 plumbing_response = self.stub.Delete( 2645 req, 2646 metadata=self.parent.get_metadata('IdentitySets.Delete', 2647 req), 2648 timeout=t) 2649 except Exception as e: 2650 if self.parent.shouldRetry(tries, e, deadline): 2651 tries += 1 2652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2653 continue 2654 raise plumbing.convert_error_to_porcelain(e) from e 2655 break 2656 2657 resp = models.IdentitySetDeleteResponse() 2658 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2659 plumbing_response.meta) 2660 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2661 plumbing_response.rate_limit) 2662 return resp 2663 2664 def list(self, filter, *args, timeout=None): 2665 ''' 2666 List gets a list of IdentitySets matching a given set of criteria. 2667 ''' 2668 deadline = None if timeout is None else time.time() + timeout 2669 req = IdentitySetListRequest() 2670 req.meta.CopyFrom(ListRequestMetadata()) 2671 if self.parent.page_limit > 0: 2672 req.meta.limit = self.parent.page_limit 2673 if self.parent.snapshot_datetime is not None: 2674 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2675 2676 req.filter = plumbing.quote_filter_args(filter, *args) 2677 2678 def generator(svc, req): 2679 tries = 0 2680 while True: 2681 t = None if deadline is None else deadline - time.time() 2682 try: 2683 plumbing_response = svc.stub.List( 2684 req, 2685 metadata=svc.parent.get_metadata( 2686 'IdentitySets.List', req), 2687 timeout=t) 2688 except Exception as e: 2689 if self.parent.shouldRetry(tries, e, deadline): 2690 tries += 1 2691 time.sleep( 2692 self.parent.exponentialBackoff(tries, deadline)) 2693 continue 2694 raise plumbing.convert_error_to_porcelain(e) from e 2695 tries = 0 2696 for plumbing_item in plumbing_response.identity_sets: 2697 yield plumbing.convert_identity_set_to_porcelain( 2698 plumbing_item) 2699 if plumbing_response.meta.next_cursor == '': 2700 break 2701 req.meta.cursor = plumbing_response.meta.next_cursor 2702 2703 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)
2520 def create(self, identity_set, timeout=None): 2521 ''' 2522 Create registers a new IdentitySet. 2523 ''' 2524 deadline = None if timeout is None else time.time() + timeout 2525 req = IdentitySetCreateRequest() 2526 2527 if identity_set is not None: 2528 req.identity_set.CopyFrom( 2529 plumbing.convert_identity_set_to_plumbing(identity_set)) 2530 tries = 0 2531 plumbing_response = None 2532 while True: 2533 t = None if deadline is None else deadline - time.time() 2534 try: 2535 plumbing_response = self.stub.Create( 2536 req, 2537 metadata=self.parent.get_metadata('IdentitySets.Create', 2538 req), 2539 timeout=t) 2540 except Exception as e: 2541 if self.parent.shouldRetry(tries, e, deadline): 2542 tries += 1 2543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2544 continue 2545 raise plumbing.convert_error_to_porcelain(e) from e 2546 break 2547 2548 resp = models.IdentitySetCreateResponse() 2549 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2550 plumbing_response.identity_set) 2551 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2552 plumbing_response.meta) 2553 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2554 plumbing_response.rate_limit) 2555 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
2557 def get(self, id, timeout=None): 2558 ''' 2559 Get reads one IdentitySet by ID. 2560 ''' 2561 deadline = None if timeout is None else time.time() + timeout 2562 req = IdentitySetGetRequest() 2563 if self.parent.snapshot_datetime is not None: 2564 req.meta.CopyFrom(GetRequestMetadata()) 2565 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2566 2567 req.id = (id) 2568 tries = 0 2569 plumbing_response = None 2570 while True: 2571 t = None if deadline is None else deadline - time.time() 2572 try: 2573 plumbing_response = self.stub.Get( 2574 req, 2575 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2576 timeout=t) 2577 except Exception as e: 2578 if self.parent.shouldRetry(tries, e, deadline): 2579 tries += 1 2580 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2581 continue 2582 raise plumbing.convert_error_to_porcelain(e) from e 2583 break 2584 2585 resp = models.IdentitySetGetResponse() 2586 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2587 plumbing_response.identity_set) 2588 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2589 plumbing_response.meta) 2590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2591 plumbing_response.rate_limit) 2592 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
2594 def update(self, identity_set, timeout=None): 2595 ''' 2596 Update replaces all the fields of a IdentitySet by ID. 2597 ''' 2598 deadline = None if timeout is None else time.time() + timeout 2599 req = IdentitySetUpdateRequest() 2600 2601 if identity_set is not None: 2602 req.identity_set.CopyFrom( 2603 plumbing.convert_identity_set_to_plumbing(identity_set)) 2604 tries = 0 2605 plumbing_response = None 2606 while True: 2607 t = None if deadline is None else deadline - time.time() 2608 try: 2609 plumbing_response = self.stub.Update( 2610 req, 2611 metadata=self.parent.get_metadata('IdentitySets.Update', 2612 req), 2613 timeout=t) 2614 except Exception as e: 2615 if self.parent.shouldRetry(tries, e, deadline): 2616 tries += 1 2617 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2618 continue 2619 raise plumbing.convert_error_to_porcelain(e) from e 2620 break 2621 2622 resp = models.IdentitySetUpdateResponse() 2623 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2624 plumbing_response.identity_set) 2625 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2626 plumbing_response.meta) 2627 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2628 plumbing_response.rate_limit) 2629 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
2631 def delete(self, id, timeout=None): 2632 ''' 2633 Delete removes a IdentitySet by ID. 2634 ''' 2635 deadline = None if timeout is None else time.time() + timeout 2636 req = IdentitySetDeleteRequest() 2637 2638 req.id = (id) 2639 tries = 0 2640 plumbing_response = None 2641 while True: 2642 t = None if deadline is None else deadline - time.time() 2643 try: 2644 plumbing_response = self.stub.Delete( 2645 req, 2646 metadata=self.parent.get_metadata('IdentitySets.Delete', 2647 req), 2648 timeout=t) 2649 except Exception as e: 2650 if self.parent.shouldRetry(tries, e, deadline): 2651 tries += 1 2652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2653 continue 2654 raise plumbing.convert_error_to_porcelain(e) from e 2655 break 2656 2657 resp = models.IdentitySetDeleteResponse() 2658 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2659 plumbing_response.meta) 2660 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2661 plumbing_response.rate_limit) 2662 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2664 def list(self, filter, *args, timeout=None): 2665 ''' 2666 List gets a list of IdentitySets matching a given set of criteria. 2667 ''' 2668 deadline = None if timeout is None else time.time() + timeout 2669 req = IdentitySetListRequest() 2670 req.meta.CopyFrom(ListRequestMetadata()) 2671 if self.parent.page_limit > 0: 2672 req.meta.limit = self.parent.page_limit 2673 if self.parent.snapshot_datetime is not None: 2674 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2675 2676 req.filter = plumbing.quote_filter_args(filter, *args) 2677 2678 def generator(svc, req): 2679 tries = 0 2680 while True: 2681 t = None if deadline is None else deadline - time.time() 2682 try: 2683 plumbing_response = svc.stub.List( 2684 req, 2685 metadata=svc.parent.get_metadata( 2686 'IdentitySets.List', req), 2687 timeout=t) 2688 except Exception as e: 2689 if self.parent.shouldRetry(tries, e, deadline): 2690 tries += 1 2691 time.sleep( 2692 self.parent.exponentialBackoff(tries, deadline)) 2693 continue 2694 raise plumbing.convert_error_to_porcelain(e) from e 2695 tries = 0 2696 for plumbing_item in plumbing_response.identity_sets: 2697 yield plumbing.convert_identity_set_to_porcelain( 2698 plumbing_item) 2699 if plumbing_response.meta.next_cursor == '': 2700 break 2701 req.meta.cursor = plumbing_response.meta.next_cursor 2702 2703 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
2706class SnapshotIdentitySets: 2707 ''' 2708 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2709 service for historical queries. 2710 ''' 2711 def __init__(self, identity_sets): 2712 self.identity_sets = identity_sets 2713 2714 def get(self, id, timeout=None): 2715 ''' 2716 Get reads one IdentitySet by ID. 2717 ''' 2718 return self.identity_sets.get(id, timeout=timeout) 2719 2720 def list(self, filter, *args, timeout=None): 2721 ''' 2722 List gets a list of IdentitySets matching a given set of criteria. 2723 ''' 2724 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)
2714 def get(self, id, timeout=None): 2715 ''' 2716 Get reads one IdentitySet by ID. 2717 ''' 2718 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2720 def list(self, filter, *args, timeout=None): 2721 ''' 2722 List gets a list of IdentitySets matching a given set of criteria. 2723 ''' 2724 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
2727class IdentitySetsHistory: 2728 ''' 2729 IdentitySetsHistory records all changes to the state of a IdentitySet. 2730 See `strongdm.models.IdentitySetHistory`. 2731 ''' 2732 def __init__(self, channel, client): 2733 self.parent = client 2734 self.stub = IdentitySetsHistoryStub(channel) 2735 2736 def list(self, filter, *args, timeout=None): 2737 ''' 2738 List gets a list of IdentitySetHistory records matching a given set of criteria. 2739 ''' 2740 deadline = None if timeout is None else time.time() + timeout 2741 req = IdentitySetHistoryListRequest() 2742 req.meta.CopyFrom(ListRequestMetadata()) 2743 if self.parent.page_limit > 0: 2744 req.meta.limit = self.parent.page_limit 2745 if self.parent.snapshot_datetime is not None: 2746 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2747 2748 req.filter = plumbing.quote_filter_args(filter, *args) 2749 2750 def generator(svc, req): 2751 tries = 0 2752 while True: 2753 t = None if deadline is None else deadline - time.time() 2754 try: 2755 plumbing_response = svc.stub.List( 2756 req, 2757 metadata=svc.parent.get_metadata( 2758 'IdentitySetsHistory.List', req), 2759 timeout=t) 2760 except Exception as e: 2761 if self.parent.shouldRetry(tries, e, deadline): 2762 tries += 1 2763 time.sleep( 2764 self.parent.exponentialBackoff(tries, deadline)) 2765 continue 2766 raise plumbing.convert_error_to_porcelain(e) from e 2767 tries = 0 2768 for plumbing_item in plumbing_response.history: 2769 yield plumbing.convert_identity_set_history_to_porcelain( 2770 plumbing_item) 2771 if plumbing_response.meta.next_cursor == '': 2772 break 2773 req.meta.cursor = plumbing_response.meta.next_cursor 2774 2775 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)
2736 def list(self, filter, *args, timeout=None): 2737 ''' 2738 List gets a list of IdentitySetHistory records matching a given set of criteria. 2739 ''' 2740 deadline = None if timeout is None else time.time() + timeout 2741 req = IdentitySetHistoryListRequest() 2742 req.meta.CopyFrom(ListRequestMetadata()) 2743 if self.parent.page_limit > 0: 2744 req.meta.limit = self.parent.page_limit 2745 if self.parent.snapshot_datetime is not None: 2746 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2747 2748 req.filter = plumbing.quote_filter_args(filter, *args) 2749 2750 def generator(svc, req): 2751 tries = 0 2752 while True: 2753 t = None if deadline is None else deadline - time.time() 2754 try: 2755 plumbing_response = svc.stub.List( 2756 req, 2757 metadata=svc.parent.get_metadata( 2758 'IdentitySetsHistory.List', req), 2759 timeout=t) 2760 except Exception as e: 2761 if self.parent.shouldRetry(tries, e, deadline): 2762 tries += 1 2763 time.sleep( 2764 self.parent.exponentialBackoff(tries, deadline)) 2765 continue 2766 raise plumbing.convert_error_to_porcelain(e) from e 2767 tries = 0 2768 for plumbing_item in plumbing_response.history: 2769 yield plumbing.convert_identity_set_history_to_porcelain( 2770 plumbing_item) 2771 if plumbing_response.meta.next_cursor == '': 2772 break 2773 req.meta.cursor = plumbing_response.meta.next_cursor 2774 2775 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
2778class ManagedSecrets: 2779 ''' 2780 ManagedSecret is a private vertical for creating, reading, updating, 2781 deleting, listing and rotating the managed secrets in the secrets engines as 2782 an authenticated user. 2783 See `strongdm.models.ManagedSecret`. 2784 ''' 2785 def __init__(self, channel, client): 2786 self.parent = client 2787 self.stub = ManagedSecretsStub(channel) 2788 2789 def list(self, filter, *args, timeout=None): 2790 ''' 2791 List returns Managed Secrets from a Secret Engine. 2792 ''' 2793 deadline = None if timeout is None else time.time() + timeout 2794 req = ManagedSecretListRequest() 2795 req.meta.CopyFrom(ListRequestMetadata()) 2796 if self.parent.page_limit > 0: 2797 req.meta.limit = self.parent.page_limit 2798 if self.parent.snapshot_datetime is not None: 2799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2800 2801 req.filter = plumbing.quote_filter_args(filter, *args) 2802 2803 def generator(svc, req): 2804 tries = 0 2805 while True: 2806 t = None if deadline is None else deadline - time.time() 2807 try: 2808 plumbing_response = svc.stub.List( 2809 req, 2810 metadata=svc.parent.get_metadata( 2811 'ManagedSecrets.List', req), 2812 timeout=t) 2813 except Exception as e: 2814 if self.parent.shouldRetry(tries, e, deadline): 2815 tries += 1 2816 time.sleep( 2817 self.parent.exponentialBackoff(tries, deadline)) 2818 continue 2819 raise plumbing.convert_error_to_porcelain(e) from e 2820 tries = 0 2821 for plumbing_item in plumbing_response.managed_secrets: 2822 yield plumbing.convert_managed_secret_to_porcelain( 2823 plumbing_item) 2824 if plumbing_response.meta.next_cursor == '': 2825 break 2826 req.meta.cursor = plumbing_response.meta.next_cursor 2827 2828 return generator(self, req) 2829 2830 def list_by_actor(self, filter, *args, timeout=None): 2831 ''' 2832 List returns Managed Secrets for an Actor from a Secret Engine. 2833 ''' 2834 deadline = None if timeout is None else time.time() + timeout 2835 req = ManagedSecretListRequest() 2836 req.meta.CopyFrom(ListRequestMetadata()) 2837 if self.parent.page_limit > 0: 2838 req.meta.limit = self.parent.page_limit 2839 if self.parent.snapshot_datetime is not None: 2840 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2841 2842 req.filter = plumbing.quote_filter_args(filter, *args) 2843 2844 def generator(svc, req): 2845 tries = 0 2846 while True: 2847 t = None if deadline is None else deadline - time.time() 2848 try: 2849 plumbing_response = svc.stub.ListByActor( 2850 req, 2851 metadata=svc.parent.get_metadata( 2852 'ManagedSecrets.ListByActor', req), 2853 timeout=t) 2854 except Exception as e: 2855 if self.parent.shouldRetry(tries, e, deadline): 2856 tries += 1 2857 time.sleep( 2858 self.parent.exponentialBackoff(tries, deadline)) 2859 continue 2860 raise plumbing.convert_error_to_porcelain(e) from e 2861 tries = 0 2862 for plumbing_item in plumbing_response.managed_secrets: 2863 yield plumbing.convert_managed_secret_to_porcelain( 2864 plumbing_item) 2865 if plumbing_response.meta.next_cursor == '': 2866 break 2867 req.meta.cursor = plumbing_response.meta.next_cursor 2868 2869 return generator(self, req) 2870 2871 def create(self, managed_secret, timeout=None): 2872 ''' 2873 Create creates a Managed Secret 2874 ''' 2875 deadline = None if timeout is None else time.time() + timeout 2876 req = ManagedSecretCreateRequest() 2877 2878 if managed_secret is not None: 2879 req.managed_secret.CopyFrom( 2880 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2881 tries = 0 2882 plumbing_response = None 2883 while True: 2884 t = None if deadline is None else deadline - time.time() 2885 try: 2886 plumbing_response = self.stub.Create( 2887 req, 2888 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2889 req), 2890 timeout=t) 2891 except Exception as e: 2892 if self.parent.shouldRetry(tries, e, deadline): 2893 tries += 1 2894 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2895 continue 2896 raise plumbing.convert_error_to_porcelain(e) from e 2897 break 2898 2899 resp = models.ManagedSecretCreateResponse() 2900 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2901 plumbing_response.managed_secret) 2902 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2903 plumbing_response.meta) 2904 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2905 plumbing_response.rate_limit) 2906 return resp 2907 2908 def update(self, managed_secret, timeout=None): 2909 ''' 2910 Update updates a Managed Secret 2911 ''' 2912 deadline = None if timeout is None else time.time() + timeout 2913 req = ManagedSecretUpdateRequest() 2914 2915 if managed_secret is not None: 2916 req.managed_secret.CopyFrom( 2917 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2918 tries = 0 2919 plumbing_response = None 2920 while True: 2921 t = None if deadline is None else deadline - time.time() 2922 try: 2923 plumbing_response = self.stub.Update( 2924 req, 2925 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2926 req), 2927 timeout=t) 2928 except Exception as e: 2929 if self.parent.shouldRetry(tries, e, deadline): 2930 tries += 1 2931 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2932 continue 2933 raise plumbing.convert_error_to_porcelain(e) from e 2934 break 2935 2936 resp = models.ManagedSecretUpdateResponse() 2937 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2938 plumbing_response.managed_secret) 2939 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2940 plumbing_response.meta) 2941 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2942 plumbing_response.rate_limit) 2943 return resp 2944 2945 def rotate(self, id, timeout=None): 2946 ''' 2947 Rotate forces rotation of Managed Secret 2948 ''' 2949 deadline = None if timeout is None else time.time() + timeout 2950 req = ManagedSecretRotateRequest() 2951 2952 req.id = (id) 2953 tries = 0 2954 plumbing_response = None 2955 while True: 2956 t = None if deadline is None else deadline - time.time() 2957 try: 2958 plumbing_response = self.stub.Rotate( 2959 req, 2960 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2961 req), 2962 timeout=t) 2963 except Exception as e: 2964 if self.parent.shouldRetry(tries, e, deadline): 2965 tries += 1 2966 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2967 continue 2968 raise plumbing.convert_error_to_porcelain(e) from e 2969 break 2970 2971 resp = models.ManagedSecretRotateResponse() 2972 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2973 plumbing_response.meta) 2974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2975 plumbing_response.rate_limit) 2976 return resp 2977 2978 def delete(self, id, timeout=None): 2979 ''' 2980 Delete deletes a Managed Secret 2981 ''' 2982 deadline = None if timeout is None else time.time() + timeout 2983 req = ManagedSecretDeleteRequest() 2984 2985 req.id = (id) 2986 tries = 0 2987 plumbing_response = None 2988 while True: 2989 t = None if deadline is None else deadline - time.time() 2990 try: 2991 plumbing_response = self.stub.Delete( 2992 req, 2993 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2994 req), 2995 timeout=t) 2996 except Exception as e: 2997 if self.parent.shouldRetry(tries, e, deadline): 2998 tries += 1 2999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3000 continue 3001 raise plumbing.convert_error_to_porcelain(e) from e 3002 break 3003 3004 resp = models.ManagedSecretDeleteResponse() 3005 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3006 plumbing_response.rate_limit) 3007 return resp 3008 3009 def get(self, id, timeout=None): 3010 ''' 3011 Get gets details of a Managed Secret without sensitive data 3012 ''' 3013 deadline = None if timeout is None else time.time() + timeout 3014 req = ManagedSecretGetRequest() 3015 if self.parent.snapshot_datetime is not None: 3016 req.meta.CopyFrom(GetRequestMetadata()) 3017 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3018 3019 req.id = (id) 3020 tries = 0 3021 plumbing_response = None 3022 while True: 3023 t = None if deadline is None else deadline - time.time() 3024 try: 3025 plumbing_response = self.stub.Get( 3026 req, 3027 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3028 req), 3029 timeout=t) 3030 except Exception as e: 3031 if self.parent.shouldRetry(tries, e, deadline): 3032 tries += 1 3033 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3034 continue 3035 raise plumbing.convert_error_to_porcelain(e) from e 3036 break 3037 3038 resp = models.ManagedSecretGetResponse() 3039 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3040 plumbing_response.managed_secret) 3041 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3042 plumbing_response.meta) 3043 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3044 plumbing_response.rate_limit) 3045 return resp 3046 3047 def retrieve(self, id, public_key, timeout=None): 3048 ''' 3049 Retrieve returns Managed Secret with sensitive data 3050 ''' 3051 deadline = None if timeout is None else time.time() + timeout 3052 req = ManagedSecretRetrieveRequest() 3053 3054 req.id = (id) 3055 req.public_key = (public_key) 3056 tries = 0 3057 plumbing_response = None 3058 while True: 3059 t = None if deadline is None else deadline - time.time() 3060 try: 3061 plumbing_response = self.stub.Retrieve( 3062 req, 3063 metadata=self.parent.get_metadata( 3064 'ManagedSecrets.Retrieve', req), 3065 timeout=t) 3066 except Exception as e: 3067 if self.parent.shouldRetry(tries, e, deadline): 3068 tries += 1 3069 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3070 continue 3071 raise plumbing.convert_error_to_porcelain(e) from e 3072 break 3073 3074 resp = models.ManagedSecretRetrieveResponse() 3075 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3076 plumbing_response.managed_secret) 3077 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3078 plumbing_response.meta) 3079 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3080 plumbing_response.rate_limit) 3081 return resp 3082 3083 def validate(self, id, timeout=None): 3084 ''' 3085 Validate returns the result of testing the stored credential against the 3086 secret engine. 3087 ''' 3088 deadline = None if timeout is None else time.time() + timeout 3089 req = ManagedSecretValidateRequest() 3090 3091 req.id = (id) 3092 tries = 0 3093 plumbing_response = None 3094 while True: 3095 t = None if deadline is None else deadline - time.time() 3096 try: 3097 plumbing_response = self.stub.Validate( 3098 req, 3099 metadata=self.parent.get_metadata( 3100 'ManagedSecrets.Validate', req), 3101 timeout=t) 3102 except Exception as e: 3103 if self.parent.shouldRetry(tries, e, deadline): 3104 tries += 1 3105 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3106 continue 3107 raise plumbing.convert_error_to_porcelain(e) from e 3108 break 3109 3110 resp = models.ManagedSecretValidateResponse() 3111 resp.invalid_info = (plumbing_response.invalid_info) 3112 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3113 plumbing_response.meta) 3114 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3115 plumbing_response.rate_limit) 3116 resp.valid = (plumbing_response.valid) 3117 return resp 3118 3119 def logs(self, filter, *args, timeout=None): 3120 ''' 3121 Logs returns the audit records for the managed secret. This may be replaced 3122 in the future. 3123 ''' 3124 deadline = None if timeout is None else time.time() + timeout 3125 req = ManagedSecretLogsRequest() 3126 req.meta.CopyFrom(ListRequestMetadata()) 3127 if self.parent.page_limit > 0: 3128 req.meta.limit = self.parent.page_limit 3129 if self.parent.snapshot_datetime is not None: 3130 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3131 3132 req.filter = plumbing.quote_filter_args(filter, *args) 3133 3134 def generator(svc, req): 3135 tries = 0 3136 while True: 3137 t = None if deadline is None else deadline - time.time() 3138 try: 3139 plumbing_response = svc.stub.Logs( 3140 req, 3141 metadata=svc.parent.get_metadata( 3142 'ManagedSecrets.Logs', req), 3143 timeout=t) 3144 except Exception as e: 3145 if self.parent.shouldRetry(tries, e, deadline): 3146 tries += 1 3147 time.sleep( 3148 self.parent.exponentialBackoff(tries, deadline)) 3149 continue 3150 raise plumbing.convert_error_to_porcelain(e) from e 3151 tries = 0 3152 for plumbing_item in plumbing_response.managed_secret_logs: 3153 yield plumbing.convert_managed_secret_log_to_porcelain( 3154 plumbing_item) 3155 if plumbing_response.meta.next_cursor == '': 3156 break 3157 req.meta.cursor = plumbing_response.meta.next_cursor 3158 3159 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)
2789 def list(self, filter, *args, timeout=None): 2790 ''' 2791 List returns Managed Secrets from a Secret Engine. 2792 ''' 2793 deadline = None if timeout is None else time.time() + timeout 2794 req = ManagedSecretListRequest() 2795 req.meta.CopyFrom(ListRequestMetadata()) 2796 if self.parent.page_limit > 0: 2797 req.meta.limit = self.parent.page_limit 2798 if self.parent.snapshot_datetime is not None: 2799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2800 2801 req.filter = plumbing.quote_filter_args(filter, *args) 2802 2803 def generator(svc, req): 2804 tries = 0 2805 while True: 2806 t = None if deadline is None else deadline - time.time() 2807 try: 2808 plumbing_response = svc.stub.List( 2809 req, 2810 metadata=svc.parent.get_metadata( 2811 'ManagedSecrets.List', req), 2812 timeout=t) 2813 except Exception as e: 2814 if self.parent.shouldRetry(tries, e, deadline): 2815 tries += 1 2816 time.sleep( 2817 self.parent.exponentialBackoff(tries, deadline)) 2818 continue 2819 raise plumbing.convert_error_to_porcelain(e) from e 2820 tries = 0 2821 for plumbing_item in plumbing_response.managed_secrets: 2822 yield plumbing.convert_managed_secret_to_porcelain( 2823 plumbing_item) 2824 if plumbing_response.meta.next_cursor == '': 2825 break 2826 req.meta.cursor = plumbing_response.meta.next_cursor 2827 2828 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
2830 def list_by_actor(self, filter, *args, timeout=None): 2831 ''' 2832 List returns Managed Secrets for an Actor from a Secret Engine. 2833 ''' 2834 deadline = None if timeout is None else time.time() + timeout 2835 req = ManagedSecretListRequest() 2836 req.meta.CopyFrom(ListRequestMetadata()) 2837 if self.parent.page_limit > 0: 2838 req.meta.limit = self.parent.page_limit 2839 if self.parent.snapshot_datetime is not None: 2840 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2841 2842 req.filter = plumbing.quote_filter_args(filter, *args) 2843 2844 def generator(svc, req): 2845 tries = 0 2846 while True: 2847 t = None if deadline is None else deadline - time.time() 2848 try: 2849 plumbing_response = svc.stub.ListByActor( 2850 req, 2851 metadata=svc.parent.get_metadata( 2852 'ManagedSecrets.ListByActor', req), 2853 timeout=t) 2854 except Exception as e: 2855 if self.parent.shouldRetry(tries, e, deadline): 2856 tries += 1 2857 time.sleep( 2858 self.parent.exponentialBackoff(tries, deadline)) 2859 continue 2860 raise plumbing.convert_error_to_porcelain(e) from e 2861 tries = 0 2862 for plumbing_item in plumbing_response.managed_secrets: 2863 yield plumbing.convert_managed_secret_to_porcelain( 2864 plumbing_item) 2865 if plumbing_response.meta.next_cursor == '': 2866 break 2867 req.meta.cursor = plumbing_response.meta.next_cursor 2868 2869 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
2871 def create(self, managed_secret, timeout=None): 2872 ''' 2873 Create creates a Managed Secret 2874 ''' 2875 deadline = None if timeout is None else time.time() + timeout 2876 req = ManagedSecretCreateRequest() 2877 2878 if managed_secret is not None: 2879 req.managed_secret.CopyFrom( 2880 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2881 tries = 0 2882 plumbing_response = None 2883 while True: 2884 t = None if deadline is None else deadline - time.time() 2885 try: 2886 plumbing_response = self.stub.Create( 2887 req, 2888 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2889 req), 2890 timeout=t) 2891 except Exception as e: 2892 if self.parent.shouldRetry(tries, e, deadline): 2893 tries += 1 2894 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2895 continue 2896 raise plumbing.convert_error_to_porcelain(e) from e 2897 break 2898 2899 resp = models.ManagedSecretCreateResponse() 2900 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2901 plumbing_response.managed_secret) 2902 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2903 plumbing_response.meta) 2904 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2905 plumbing_response.rate_limit) 2906 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
2908 def update(self, managed_secret, timeout=None): 2909 ''' 2910 Update updates a Managed Secret 2911 ''' 2912 deadline = None if timeout is None else time.time() + timeout 2913 req = ManagedSecretUpdateRequest() 2914 2915 if managed_secret is not None: 2916 req.managed_secret.CopyFrom( 2917 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2918 tries = 0 2919 plumbing_response = None 2920 while True: 2921 t = None if deadline is None else deadline - time.time() 2922 try: 2923 plumbing_response = self.stub.Update( 2924 req, 2925 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2926 req), 2927 timeout=t) 2928 except Exception as e: 2929 if self.parent.shouldRetry(tries, e, deadline): 2930 tries += 1 2931 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2932 continue 2933 raise plumbing.convert_error_to_porcelain(e) from e 2934 break 2935 2936 resp = models.ManagedSecretUpdateResponse() 2937 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2938 plumbing_response.managed_secret) 2939 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2940 plumbing_response.meta) 2941 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2942 plumbing_response.rate_limit) 2943 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
2945 def rotate(self, id, timeout=None): 2946 ''' 2947 Rotate forces rotation of Managed Secret 2948 ''' 2949 deadline = None if timeout is None else time.time() + timeout 2950 req = ManagedSecretRotateRequest() 2951 2952 req.id = (id) 2953 tries = 0 2954 plumbing_response = None 2955 while True: 2956 t = None if deadline is None else deadline - time.time() 2957 try: 2958 plumbing_response = self.stub.Rotate( 2959 req, 2960 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2961 req), 2962 timeout=t) 2963 except Exception as e: 2964 if self.parent.shouldRetry(tries, e, deadline): 2965 tries += 1 2966 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2967 continue 2968 raise plumbing.convert_error_to_porcelain(e) from e 2969 break 2970 2971 resp = models.ManagedSecretRotateResponse() 2972 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2973 plumbing_response.meta) 2974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2975 plumbing_response.rate_limit) 2976 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
2978 def delete(self, id, timeout=None): 2979 ''' 2980 Delete deletes a Managed Secret 2981 ''' 2982 deadline = None if timeout is None else time.time() + timeout 2983 req = ManagedSecretDeleteRequest() 2984 2985 req.id = (id) 2986 tries = 0 2987 plumbing_response = None 2988 while True: 2989 t = None if deadline is None else deadline - time.time() 2990 try: 2991 plumbing_response = self.stub.Delete( 2992 req, 2993 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2994 req), 2995 timeout=t) 2996 except Exception as e: 2997 if self.parent.shouldRetry(tries, e, deadline): 2998 tries += 1 2999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3000 continue 3001 raise plumbing.convert_error_to_porcelain(e) from e 3002 break 3003 3004 resp = models.ManagedSecretDeleteResponse() 3005 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3006 plumbing_response.rate_limit) 3007 return resp
Delete deletes a Managed Secret
def
get(self, id, timeout=None)
3009 def get(self, id, timeout=None): 3010 ''' 3011 Get gets details of a Managed Secret without sensitive data 3012 ''' 3013 deadline = None if timeout is None else time.time() + timeout 3014 req = ManagedSecretGetRequest() 3015 if self.parent.snapshot_datetime is not None: 3016 req.meta.CopyFrom(GetRequestMetadata()) 3017 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3018 3019 req.id = (id) 3020 tries = 0 3021 plumbing_response = None 3022 while True: 3023 t = None if deadline is None else deadline - time.time() 3024 try: 3025 plumbing_response = self.stub.Get( 3026 req, 3027 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3028 req), 3029 timeout=t) 3030 except Exception as e: 3031 if self.parent.shouldRetry(tries, e, deadline): 3032 tries += 1 3033 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3034 continue 3035 raise plumbing.convert_error_to_porcelain(e) from e 3036 break 3037 3038 resp = models.ManagedSecretGetResponse() 3039 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3040 plumbing_response.managed_secret) 3041 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3042 plumbing_response.meta) 3043 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3044 plumbing_response.rate_limit) 3045 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, public_key, timeout=None)
3047 def retrieve(self, id, public_key, timeout=None): 3048 ''' 3049 Retrieve returns Managed Secret with sensitive data 3050 ''' 3051 deadline = None if timeout is None else time.time() + timeout 3052 req = ManagedSecretRetrieveRequest() 3053 3054 req.id = (id) 3055 req.public_key = (public_key) 3056 tries = 0 3057 plumbing_response = None 3058 while True: 3059 t = None if deadline is None else deadline - time.time() 3060 try: 3061 plumbing_response = self.stub.Retrieve( 3062 req, 3063 metadata=self.parent.get_metadata( 3064 'ManagedSecrets.Retrieve', req), 3065 timeout=t) 3066 except Exception as e: 3067 if self.parent.shouldRetry(tries, e, deadline): 3068 tries += 1 3069 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3070 continue 3071 raise plumbing.convert_error_to_porcelain(e) from e 3072 break 3073 3074 resp = models.ManagedSecretRetrieveResponse() 3075 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3076 plumbing_response.managed_secret) 3077 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3078 plumbing_response.meta) 3079 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3080 plumbing_response.rate_limit) 3081 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
3083 def validate(self, id, timeout=None): 3084 ''' 3085 Validate returns the result of testing the stored credential against the 3086 secret engine. 3087 ''' 3088 deadline = None if timeout is None else time.time() + timeout 3089 req = ManagedSecretValidateRequest() 3090 3091 req.id = (id) 3092 tries = 0 3093 plumbing_response = None 3094 while True: 3095 t = None if deadline is None else deadline - time.time() 3096 try: 3097 plumbing_response = self.stub.Validate( 3098 req, 3099 metadata=self.parent.get_metadata( 3100 'ManagedSecrets.Validate', req), 3101 timeout=t) 3102 except Exception as e: 3103 if self.parent.shouldRetry(tries, e, deadline): 3104 tries += 1 3105 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3106 continue 3107 raise plumbing.convert_error_to_porcelain(e) from e 3108 break 3109 3110 resp = models.ManagedSecretValidateResponse() 3111 resp.invalid_info = (plumbing_response.invalid_info) 3112 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3113 plumbing_response.meta) 3114 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3115 plumbing_response.rate_limit) 3116 resp.valid = (plumbing_response.valid) 3117 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
3119 def logs(self, filter, *args, timeout=None): 3120 ''' 3121 Logs returns the audit records for the managed secret. This may be replaced 3122 in the future. 3123 ''' 3124 deadline = None if timeout is None else time.time() + timeout 3125 req = ManagedSecretLogsRequest() 3126 req.meta.CopyFrom(ListRequestMetadata()) 3127 if self.parent.page_limit > 0: 3128 req.meta.limit = self.parent.page_limit 3129 if self.parent.snapshot_datetime is not None: 3130 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3131 3132 req.filter = plumbing.quote_filter_args(filter, *args) 3133 3134 def generator(svc, req): 3135 tries = 0 3136 while True: 3137 t = None if deadline is None else deadline - time.time() 3138 try: 3139 plumbing_response = svc.stub.Logs( 3140 req, 3141 metadata=svc.parent.get_metadata( 3142 'ManagedSecrets.Logs', req), 3143 timeout=t) 3144 except Exception as e: 3145 if self.parent.shouldRetry(tries, e, deadline): 3146 tries += 1 3147 time.sleep( 3148 self.parent.exponentialBackoff(tries, deadline)) 3149 continue 3150 raise plumbing.convert_error_to_porcelain(e) from e 3151 tries = 0 3152 for plumbing_item in plumbing_response.managed_secret_logs: 3153 yield plumbing.convert_managed_secret_log_to_porcelain( 3154 plumbing_item) 3155 if plumbing_response.meta.next_cursor == '': 3156 break 3157 req.meta.cursor = plumbing_response.meta.next_cursor 3158 3159 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
3162class Nodes: 3163 ''' 3164 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3165 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3166 - **Relays** are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections. 3167 See: 3168 `strongdm.models.Gateway` 3169 `strongdm.models.ProxyCluster` 3170 `strongdm.models.Relay` 3171 ''' 3172 def __init__(self, channel, client): 3173 self.parent = client 3174 self.stub = NodesStub(channel) 3175 3176 def create(self, node, timeout=None): 3177 ''' 3178 Create registers a new Node. 3179 ''' 3180 deadline = None if timeout is None else time.time() + timeout 3181 req = NodeCreateRequest() 3182 3183 if node is not None: 3184 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3185 tries = 0 3186 plumbing_response = None 3187 while True: 3188 t = None if deadline is None else deadline - time.time() 3189 try: 3190 plumbing_response = self.stub.Create( 3191 req, 3192 metadata=self.parent.get_metadata('Nodes.Create', req), 3193 timeout=t) 3194 except Exception as e: 3195 if self.parent.shouldRetry(tries, e, deadline): 3196 tries += 1 3197 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3198 continue 3199 raise plumbing.convert_error_to_porcelain(e) from e 3200 break 3201 3202 resp = models.NodeCreateResponse() 3203 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3204 plumbing_response.meta) 3205 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3206 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3207 plumbing_response.rate_limit) 3208 resp.token = (plumbing_response.token) 3209 return resp 3210 3211 def get(self, id, timeout=None): 3212 ''' 3213 Get reads one Node by ID. 3214 ''' 3215 deadline = None if timeout is None else time.time() + timeout 3216 req = NodeGetRequest() 3217 if self.parent.snapshot_datetime is not None: 3218 req.meta.CopyFrom(GetRequestMetadata()) 3219 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3220 3221 req.id = (id) 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.Get( 3228 req, 3229 metadata=self.parent.get_metadata('Nodes.Get', req), 3230 timeout=t) 3231 except Exception as e: 3232 if self.parent.shouldRetry(tries, e, deadline): 3233 tries += 1 3234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3235 continue 3236 raise plumbing.convert_error_to_porcelain(e) from e 3237 break 3238 3239 resp = models.NodeGetResponse() 3240 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3241 plumbing_response.meta) 3242 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3243 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3244 plumbing_response.rate_limit) 3245 return resp 3246 3247 def update(self, node, timeout=None): 3248 ''' 3249 Update replaces all the fields of a Node by ID. 3250 ''' 3251 deadline = None if timeout is None else time.time() + timeout 3252 req = NodeUpdateRequest() 3253 3254 if node is not None: 3255 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3256 tries = 0 3257 plumbing_response = None 3258 while True: 3259 t = None if deadline is None else deadline - time.time() 3260 try: 3261 plumbing_response = self.stub.Update( 3262 req, 3263 metadata=self.parent.get_metadata('Nodes.Update', req), 3264 timeout=t) 3265 except Exception as e: 3266 if self.parent.shouldRetry(tries, e, deadline): 3267 tries += 1 3268 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3269 continue 3270 raise plumbing.convert_error_to_porcelain(e) from e 3271 break 3272 3273 resp = models.NodeUpdateResponse() 3274 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3275 plumbing_response.meta) 3276 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3277 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3278 plumbing_response.rate_limit) 3279 return resp 3280 3281 def delete(self, id, timeout=None): 3282 ''' 3283 Delete removes a Node by ID. 3284 ''' 3285 deadline = None if timeout is None else time.time() + timeout 3286 req = NodeDeleteRequest() 3287 3288 req.id = (id) 3289 tries = 0 3290 plumbing_response = None 3291 while True: 3292 t = None if deadline is None else deadline - time.time() 3293 try: 3294 plumbing_response = self.stub.Delete( 3295 req, 3296 metadata=self.parent.get_metadata('Nodes.Delete', req), 3297 timeout=t) 3298 except Exception as e: 3299 if self.parent.shouldRetry(tries, e, deadline): 3300 tries += 1 3301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3302 continue 3303 raise plumbing.convert_error_to_porcelain(e) from e 3304 break 3305 3306 resp = models.NodeDeleteResponse() 3307 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3308 plumbing_response.meta) 3309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3310 plumbing_response.rate_limit) 3311 return resp 3312 3313 def list(self, filter, *args, timeout=None): 3314 ''' 3315 List gets a list of Nodes matching a given set of criteria. 3316 ''' 3317 deadline = None if timeout is None else time.time() + timeout 3318 req = NodeListRequest() 3319 req.meta.CopyFrom(ListRequestMetadata()) 3320 if self.parent.page_limit > 0: 3321 req.meta.limit = self.parent.page_limit 3322 if self.parent.snapshot_datetime is not None: 3323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3324 3325 req.filter = plumbing.quote_filter_args(filter, *args) 3326 3327 def generator(svc, req): 3328 tries = 0 3329 while True: 3330 t = None if deadline is None else deadline - time.time() 3331 try: 3332 plumbing_response = svc.stub.List( 3333 req, 3334 metadata=svc.parent.get_metadata('Nodes.List', req), 3335 timeout=t) 3336 except Exception as e: 3337 if self.parent.shouldRetry(tries, e, deadline): 3338 tries += 1 3339 time.sleep( 3340 self.parent.exponentialBackoff(tries, deadline)) 3341 continue 3342 raise plumbing.convert_error_to_porcelain(e) from e 3343 tries = 0 3344 for plumbing_item in plumbing_response.nodes: 3345 yield plumbing.convert_node_to_porcelain(plumbing_item) 3346 if plumbing_response.meta.next_cursor == '': 3347 break 3348 req.meta.cursor = plumbing_response.meta.next_cursor 3349 3350 return generator(self, req)
Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes:
- Gateways are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers.
- Relays are used to extend the strongDM network into segmented subnets. They provide access to databases and servers but do not listen for incoming connections.
See:
strongdm.models.Gatewaystrongdm.models.ProxyClusterstrongdm.models.Relay
def
create(self, node, timeout=None)
3176 def create(self, node, timeout=None): 3177 ''' 3178 Create registers a new Node. 3179 ''' 3180 deadline = None if timeout is None else time.time() + timeout 3181 req = NodeCreateRequest() 3182 3183 if node is not None: 3184 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3185 tries = 0 3186 plumbing_response = None 3187 while True: 3188 t = None if deadline is None else deadline - time.time() 3189 try: 3190 plumbing_response = self.stub.Create( 3191 req, 3192 metadata=self.parent.get_metadata('Nodes.Create', req), 3193 timeout=t) 3194 except Exception as e: 3195 if self.parent.shouldRetry(tries, e, deadline): 3196 tries += 1 3197 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3198 continue 3199 raise plumbing.convert_error_to_porcelain(e) from e 3200 break 3201 3202 resp = models.NodeCreateResponse() 3203 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3204 plumbing_response.meta) 3205 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3206 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3207 plumbing_response.rate_limit) 3208 resp.token = (plumbing_response.token) 3209 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
3211 def get(self, id, timeout=None): 3212 ''' 3213 Get reads one Node by ID. 3214 ''' 3215 deadline = None if timeout is None else time.time() + timeout 3216 req = NodeGetRequest() 3217 if self.parent.snapshot_datetime is not None: 3218 req.meta.CopyFrom(GetRequestMetadata()) 3219 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3220 3221 req.id = (id) 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.Get( 3228 req, 3229 metadata=self.parent.get_metadata('Nodes.Get', req), 3230 timeout=t) 3231 except Exception as e: 3232 if self.parent.shouldRetry(tries, e, deadline): 3233 tries += 1 3234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3235 continue 3236 raise plumbing.convert_error_to_porcelain(e) from e 3237 break 3238 3239 resp = models.NodeGetResponse() 3240 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3241 plumbing_response.meta) 3242 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3243 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3244 plumbing_response.rate_limit) 3245 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
3247 def update(self, node, timeout=None): 3248 ''' 3249 Update replaces all the fields of a Node by ID. 3250 ''' 3251 deadline = None if timeout is None else time.time() + timeout 3252 req = NodeUpdateRequest() 3253 3254 if node is not None: 3255 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3256 tries = 0 3257 plumbing_response = None 3258 while True: 3259 t = None if deadline is None else deadline - time.time() 3260 try: 3261 plumbing_response = self.stub.Update( 3262 req, 3263 metadata=self.parent.get_metadata('Nodes.Update', req), 3264 timeout=t) 3265 except Exception as e: 3266 if self.parent.shouldRetry(tries, e, deadline): 3267 tries += 1 3268 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3269 continue 3270 raise plumbing.convert_error_to_porcelain(e) from e 3271 break 3272 3273 resp = models.NodeUpdateResponse() 3274 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3275 plumbing_response.meta) 3276 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3277 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3278 plumbing_response.rate_limit) 3279 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
3281 def delete(self, id, timeout=None): 3282 ''' 3283 Delete removes a Node by ID. 3284 ''' 3285 deadline = None if timeout is None else time.time() + timeout 3286 req = NodeDeleteRequest() 3287 3288 req.id = (id) 3289 tries = 0 3290 plumbing_response = None 3291 while True: 3292 t = None if deadline is None else deadline - time.time() 3293 try: 3294 plumbing_response = self.stub.Delete( 3295 req, 3296 metadata=self.parent.get_metadata('Nodes.Delete', req), 3297 timeout=t) 3298 except Exception as e: 3299 if self.parent.shouldRetry(tries, e, deadline): 3300 tries += 1 3301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3302 continue 3303 raise plumbing.convert_error_to_porcelain(e) from e 3304 break 3305 3306 resp = models.NodeDeleteResponse() 3307 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3308 plumbing_response.meta) 3309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3310 plumbing_response.rate_limit) 3311 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
3313 def list(self, filter, *args, timeout=None): 3314 ''' 3315 List gets a list of Nodes matching a given set of criteria. 3316 ''' 3317 deadline = None if timeout is None else time.time() + timeout 3318 req = NodeListRequest() 3319 req.meta.CopyFrom(ListRequestMetadata()) 3320 if self.parent.page_limit > 0: 3321 req.meta.limit = self.parent.page_limit 3322 if self.parent.snapshot_datetime is not None: 3323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3324 3325 req.filter = plumbing.quote_filter_args(filter, *args) 3326 3327 def generator(svc, req): 3328 tries = 0 3329 while True: 3330 t = None if deadline is None else deadline - time.time() 3331 try: 3332 plumbing_response = svc.stub.List( 3333 req, 3334 metadata=svc.parent.get_metadata('Nodes.List', req), 3335 timeout=t) 3336 except Exception as e: 3337 if self.parent.shouldRetry(tries, e, deadline): 3338 tries += 1 3339 time.sleep( 3340 self.parent.exponentialBackoff(tries, deadline)) 3341 continue 3342 raise plumbing.convert_error_to_porcelain(e) from e 3343 tries = 0 3344 for plumbing_item in plumbing_response.nodes: 3345 yield plumbing.convert_node_to_porcelain(plumbing_item) 3346 if plumbing_response.meta.next_cursor == '': 3347 break 3348 req.meta.cursor = plumbing_response.meta.next_cursor 3349 3350 return generator(self, req)
List gets a list of Nodes matching a given set of criteria.
class
SnapshotNodes:
3353class SnapshotNodes: 3354 ''' 3355 SnapshotNodes exposes the read only methods of the Nodes 3356 service for historical queries. 3357 ''' 3358 def __init__(self, nodes): 3359 self.nodes = nodes 3360 3361 def get(self, id, timeout=None): 3362 ''' 3363 Get reads one Node by ID. 3364 ''' 3365 return self.nodes.get(id, timeout=timeout) 3366 3367 def list(self, filter, *args, timeout=None): 3368 ''' 3369 List gets a list of Nodes matching a given set of criteria. 3370 ''' 3371 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
3374class NodesHistory: 3375 ''' 3376 NodesHistory records all changes to the state of a Node. 3377 See `strongdm.models.NodeHistory`. 3378 ''' 3379 def __init__(self, channel, client): 3380 self.parent = client 3381 self.stub = NodesHistoryStub(channel) 3382 3383 def list(self, filter, *args, timeout=None): 3384 ''' 3385 List gets a list of NodeHistory records matching a given set of criteria. 3386 ''' 3387 deadline = None if timeout is None else time.time() + timeout 3388 req = NodeHistoryListRequest() 3389 req.meta.CopyFrom(ListRequestMetadata()) 3390 if self.parent.page_limit > 0: 3391 req.meta.limit = self.parent.page_limit 3392 if self.parent.snapshot_datetime is not None: 3393 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3394 3395 req.filter = plumbing.quote_filter_args(filter, *args) 3396 3397 def generator(svc, req): 3398 tries = 0 3399 while True: 3400 t = None if deadline is None else deadline - time.time() 3401 try: 3402 plumbing_response = svc.stub.List( 3403 req, 3404 metadata=svc.parent.get_metadata( 3405 'NodesHistory.List', req), 3406 timeout=t) 3407 except Exception as e: 3408 if self.parent.shouldRetry(tries, e, deadline): 3409 tries += 1 3410 time.sleep( 3411 self.parent.exponentialBackoff(tries, deadline)) 3412 continue 3413 raise plumbing.convert_error_to_porcelain(e) from e 3414 tries = 0 3415 for plumbing_item in plumbing_response.history: 3416 yield plumbing.convert_node_history_to_porcelain( 3417 plumbing_item) 3418 if plumbing_response.meta.next_cursor == '': 3419 break 3420 req.meta.cursor = plumbing_response.meta.next_cursor 3421 3422 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)
3383 def list(self, filter, *args, timeout=None): 3384 ''' 3385 List gets a list of NodeHistory records matching a given set of criteria. 3386 ''' 3387 deadline = None if timeout is None else time.time() + timeout 3388 req = NodeHistoryListRequest() 3389 req.meta.CopyFrom(ListRequestMetadata()) 3390 if self.parent.page_limit > 0: 3391 req.meta.limit = self.parent.page_limit 3392 if self.parent.snapshot_datetime is not None: 3393 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3394 3395 req.filter = plumbing.quote_filter_args(filter, *args) 3396 3397 def generator(svc, req): 3398 tries = 0 3399 while True: 3400 t = None if deadline is None else deadline - time.time() 3401 try: 3402 plumbing_response = svc.stub.List( 3403 req, 3404 metadata=svc.parent.get_metadata( 3405 'NodesHistory.List', req), 3406 timeout=t) 3407 except Exception as e: 3408 if self.parent.shouldRetry(tries, e, deadline): 3409 tries += 1 3410 time.sleep( 3411 self.parent.exponentialBackoff(tries, deadline)) 3412 continue 3413 raise plumbing.convert_error_to_porcelain(e) from e 3414 tries = 0 3415 for plumbing_item in plumbing_response.history: 3416 yield plumbing.convert_node_history_to_porcelain( 3417 plumbing_item) 3418 if plumbing_response.meta.next_cursor == '': 3419 break 3420 req.meta.cursor = plumbing_response.meta.next_cursor 3421 3422 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
3425class OrganizationHistory: 3426 ''' 3427 OrganizationHistory records all changes to the state of an Organization. 3428 See `strongdm.models.OrganizationHistoryRecord`. 3429 ''' 3430 def __init__(self, channel, client): 3431 self.parent = client 3432 self.stub = OrganizationHistoryStub(channel) 3433 3434 def list(self, filter, *args, timeout=None): 3435 ''' 3436 List gets a list of OrganizationHistory records matching a given set of criteria. 3437 ''' 3438 deadline = None if timeout is None else time.time() + timeout 3439 req = OrganizationHistoryListRequest() 3440 req.meta.CopyFrom(ListRequestMetadata()) 3441 if self.parent.page_limit > 0: 3442 req.meta.limit = self.parent.page_limit 3443 if self.parent.snapshot_datetime is not None: 3444 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3445 3446 req.filter = plumbing.quote_filter_args(filter, *args) 3447 3448 def generator(svc, req): 3449 tries = 0 3450 while True: 3451 t = None if deadline is None else deadline - time.time() 3452 try: 3453 plumbing_response = svc.stub.List( 3454 req, 3455 metadata=svc.parent.get_metadata( 3456 'OrganizationHistory.List', req), 3457 timeout=t) 3458 except Exception as e: 3459 if self.parent.shouldRetry(tries, e, deadline): 3460 tries += 1 3461 time.sleep( 3462 self.parent.exponentialBackoff(tries, deadline)) 3463 continue 3464 raise plumbing.convert_error_to_porcelain(e) from e 3465 tries = 0 3466 for plumbing_item in plumbing_response.history: 3467 yield plumbing.convert_organization_history_record_to_porcelain( 3468 plumbing_item) 3469 if plumbing_response.meta.next_cursor == '': 3470 break 3471 req.meta.cursor = plumbing_response.meta.next_cursor 3472 3473 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)
3434 def list(self, filter, *args, timeout=None): 3435 ''' 3436 List gets a list of OrganizationHistory records matching a given set of criteria. 3437 ''' 3438 deadline = None if timeout is None else time.time() + timeout 3439 req = OrganizationHistoryListRequest() 3440 req.meta.CopyFrom(ListRequestMetadata()) 3441 if self.parent.page_limit > 0: 3442 req.meta.limit = self.parent.page_limit 3443 if self.parent.snapshot_datetime is not None: 3444 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3445 3446 req.filter = plumbing.quote_filter_args(filter, *args) 3447 3448 def generator(svc, req): 3449 tries = 0 3450 while True: 3451 t = None if deadline is None else deadline - time.time() 3452 try: 3453 plumbing_response = svc.stub.List( 3454 req, 3455 metadata=svc.parent.get_metadata( 3456 'OrganizationHistory.List', req), 3457 timeout=t) 3458 except Exception as e: 3459 if self.parent.shouldRetry(tries, e, deadline): 3460 tries += 1 3461 time.sleep( 3462 self.parent.exponentialBackoff(tries, deadline)) 3463 continue 3464 raise plumbing.convert_error_to_porcelain(e) from e 3465 tries = 0 3466 for plumbing_item in plumbing_response.history: 3467 yield plumbing.convert_organization_history_record_to_porcelain( 3468 plumbing_item) 3469 if plumbing_response.meta.next_cursor == '': 3470 break 3471 req.meta.cursor = plumbing_response.meta.next_cursor 3472 3473 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
3476class PeeringGroupNodes: 3477 ''' 3478 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3479 See `strongdm.models.PeeringGroupNode`. 3480 ''' 3481 def __init__(self, channel, client): 3482 self.parent = client 3483 self.stub = PeeringGroupNodesStub(channel) 3484 3485 def create(self, peering_group_node, timeout=None): 3486 ''' 3487 Create attaches a Node to a PeeringGroup 3488 ''' 3489 deadline = None if timeout is None else time.time() + timeout 3490 req = PeeringGroupNodeCreateRequest() 3491 3492 if peering_group_node is not None: 3493 req.peering_group_node.CopyFrom( 3494 plumbing.convert_peering_group_node_to_plumbing( 3495 peering_group_node)) 3496 tries = 0 3497 plumbing_response = None 3498 while True: 3499 t = None if deadline is None else deadline - time.time() 3500 try: 3501 plumbing_response = self.stub.Create( 3502 req, 3503 metadata=self.parent.get_metadata( 3504 'PeeringGroupNodes.Create', req), 3505 timeout=t) 3506 except Exception as e: 3507 if self.parent.shouldRetry(tries, e, deadline): 3508 tries += 1 3509 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3510 continue 3511 raise plumbing.convert_error_to_porcelain(e) from e 3512 break 3513 3514 resp = models.PeeringGroupNodeCreateResponse() 3515 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3516 plumbing_response.meta) 3517 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3518 plumbing_response.peering_group_node) 3519 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3520 plumbing_response.rate_limit) 3521 return resp 3522 3523 def delete(self, id, timeout=None): 3524 ''' 3525 Delete detaches a Node to a PeeringGroup. 3526 ''' 3527 deadline = None if timeout is None else time.time() + timeout 3528 req = PeeringGroupNodeDeleteRequest() 3529 3530 req.id = (id) 3531 tries = 0 3532 plumbing_response = None 3533 while True: 3534 t = None if deadline is None else deadline - time.time() 3535 try: 3536 plumbing_response = self.stub.Delete( 3537 req, 3538 metadata=self.parent.get_metadata( 3539 'PeeringGroupNodes.Delete', req), 3540 timeout=t) 3541 except Exception as e: 3542 if self.parent.shouldRetry(tries, e, deadline): 3543 tries += 1 3544 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3545 continue 3546 raise plumbing.convert_error_to_porcelain(e) from e 3547 break 3548 3549 resp = models.PeeringGroupNodeDeleteResponse() 3550 resp.meta = plumbing.convert_delete_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 get(self, id, timeout=None): 3557 ''' 3558 Get reads the information of one peering group to node attachment. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = PeeringGroupNodeGetRequest() 3562 if self.parent.snapshot_datetime is not None: 3563 req.meta.CopyFrom(GetRequestMetadata()) 3564 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3565 3566 req.id = (id) 3567 tries = 0 3568 plumbing_response = None 3569 while True: 3570 t = None if deadline is None else deadline - time.time() 3571 try: 3572 plumbing_response = self.stub.Get( 3573 req, 3574 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3575 req), 3576 timeout=t) 3577 except Exception as e: 3578 if self.parent.shouldRetry(tries, e, deadline): 3579 tries += 1 3580 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3581 continue 3582 raise plumbing.convert_error_to_porcelain(e) from e 3583 break 3584 3585 resp = models.PeeringGroupNodeGetResponse() 3586 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3587 plumbing_response.meta) 3588 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3589 plumbing_response.peering_group_node) 3590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3591 plumbing_response.rate_limit) 3592 return resp 3593 3594 def list(self, filter, *args, timeout=None): 3595 ''' 3596 List gets a list of peering group node attachments. 3597 ''' 3598 deadline = None if timeout is None else time.time() + timeout 3599 req = PeeringGroupNodeListRequest() 3600 req.meta.CopyFrom(ListRequestMetadata()) 3601 if self.parent.page_limit > 0: 3602 req.meta.limit = self.parent.page_limit 3603 if self.parent.snapshot_datetime is not None: 3604 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3605 3606 req.filter = plumbing.quote_filter_args(filter, *args) 3607 3608 def generator(svc, req): 3609 tries = 0 3610 while True: 3611 t = None if deadline is None else deadline - time.time() 3612 try: 3613 plumbing_response = svc.stub.List( 3614 req, 3615 metadata=svc.parent.get_metadata( 3616 'PeeringGroupNodes.List', req), 3617 timeout=t) 3618 except Exception as e: 3619 if self.parent.shouldRetry(tries, e, deadline): 3620 tries += 1 3621 time.sleep( 3622 self.parent.exponentialBackoff(tries, deadline)) 3623 continue 3624 raise plumbing.convert_error_to_porcelain(e) from e 3625 tries = 0 3626 for plumbing_item in plumbing_response.peering_group_nodes: 3627 yield plumbing.convert_peering_group_node_to_porcelain( 3628 plumbing_item) 3629 if plumbing_response.meta.next_cursor == '': 3630 break 3631 req.meta.cursor = plumbing_response.meta.next_cursor 3632 3633 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)
3485 def create(self, peering_group_node, timeout=None): 3486 ''' 3487 Create attaches a Node to a PeeringGroup 3488 ''' 3489 deadline = None if timeout is None else time.time() + timeout 3490 req = PeeringGroupNodeCreateRequest() 3491 3492 if peering_group_node is not None: 3493 req.peering_group_node.CopyFrom( 3494 plumbing.convert_peering_group_node_to_plumbing( 3495 peering_group_node)) 3496 tries = 0 3497 plumbing_response = None 3498 while True: 3499 t = None if deadline is None else deadline - time.time() 3500 try: 3501 plumbing_response = self.stub.Create( 3502 req, 3503 metadata=self.parent.get_metadata( 3504 'PeeringGroupNodes.Create', req), 3505 timeout=t) 3506 except Exception as e: 3507 if self.parent.shouldRetry(tries, e, deadline): 3508 tries += 1 3509 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3510 continue 3511 raise plumbing.convert_error_to_porcelain(e) from e 3512 break 3513 3514 resp = models.PeeringGroupNodeCreateResponse() 3515 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3516 plumbing_response.meta) 3517 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3518 plumbing_response.peering_group_node) 3519 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3520 plumbing_response.rate_limit) 3521 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
3523 def delete(self, id, timeout=None): 3524 ''' 3525 Delete detaches a Node to a PeeringGroup. 3526 ''' 3527 deadline = None if timeout is None else time.time() + timeout 3528 req = PeeringGroupNodeDeleteRequest() 3529 3530 req.id = (id) 3531 tries = 0 3532 plumbing_response = None 3533 while True: 3534 t = None if deadline is None else deadline - time.time() 3535 try: 3536 plumbing_response = self.stub.Delete( 3537 req, 3538 metadata=self.parent.get_metadata( 3539 'PeeringGroupNodes.Delete', req), 3540 timeout=t) 3541 except Exception as e: 3542 if self.parent.shouldRetry(tries, e, deadline): 3543 tries += 1 3544 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3545 continue 3546 raise plumbing.convert_error_to_porcelain(e) from e 3547 break 3548 3549 resp = models.PeeringGroupNodeDeleteResponse() 3550 resp.meta = plumbing.convert_delete_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
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
3556 def get(self, id, timeout=None): 3557 ''' 3558 Get reads the information of one peering group to node attachment. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = PeeringGroupNodeGetRequest() 3562 if self.parent.snapshot_datetime is not None: 3563 req.meta.CopyFrom(GetRequestMetadata()) 3564 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3565 3566 req.id = (id) 3567 tries = 0 3568 plumbing_response = None 3569 while True: 3570 t = None if deadline is None else deadline - time.time() 3571 try: 3572 plumbing_response = self.stub.Get( 3573 req, 3574 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3575 req), 3576 timeout=t) 3577 except Exception as e: 3578 if self.parent.shouldRetry(tries, e, deadline): 3579 tries += 1 3580 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3581 continue 3582 raise plumbing.convert_error_to_porcelain(e) from e 3583 break 3584 3585 resp = models.PeeringGroupNodeGetResponse() 3586 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3587 plumbing_response.meta) 3588 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3589 plumbing_response.peering_group_node) 3590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3591 plumbing_response.rate_limit) 3592 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
3594 def list(self, filter, *args, timeout=None): 3595 ''' 3596 List gets a list of peering group node attachments. 3597 ''' 3598 deadline = None if timeout is None else time.time() + timeout 3599 req = PeeringGroupNodeListRequest() 3600 req.meta.CopyFrom(ListRequestMetadata()) 3601 if self.parent.page_limit > 0: 3602 req.meta.limit = self.parent.page_limit 3603 if self.parent.snapshot_datetime is not None: 3604 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3605 3606 req.filter = plumbing.quote_filter_args(filter, *args) 3607 3608 def generator(svc, req): 3609 tries = 0 3610 while True: 3611 t = None if deadline is None else deadline - time.time() 3612 try: 3613 plumbing_response = svc.stub.List( 3614 req, 3615 metadata=svc.parent.get_metadata( 3616 'PeeringGroupNodes.List', req), 3617 timeout=t) 3618 except Exception as e: 3619 if self.parent.shouldRetry(tries, e, deadline): 3620 tries += 1 3621 time.sleep( 3622 self.parent.exponentialBackoff(tries, deadline)) 3623 continue 3624 raise plumbing.convert_error_to_porcelain(e) from e 3625 tries = 0 3626 for plumbing_item in plumbing_response.peering_group_nodes: 3627 yield plumbing.convert_peering_group_node_to_porcelain( 3628 plumbing_item) 3629 if plumbing_response.meta.next_cursor == '': 3630 break 3631 req.meta.cursor = plumbing_response.meta.next_cursor 3632 3633 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
3636class PeeringGroupPeers: 3637 ''' 3638 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3639 See `strongdm.models.PeeringGroupPeer`. 3640 ''' 3641 def __init__(self, channel, client): 3642 self.parent = client 3643 self.stub = PeeringGroupPeersStub(channel) 3644 3645 def create(self, peering_group_peer, timeout=None): 3646 ''' 3647 Create links two peering groups. 3648 ''' 3649 deadline = None if timeout is None else time.time() + timeout 3650 req = PeeringGroupPeerCreateRequest() 3651 3652 if peering_group_peer is not None: 3653 req.peering_group_peer.CopyFrom( 3654 plumbing.convert_peering_group_peer_to_plumbing( 3655 peering_group_peer)) 3656 tries = 0 3657 plumbing_response = None 3658 while True: 3659 t = None if deadline is None else deadline - time.time() 3660 try: 3661 plumbing_response = self.stub.Create( 3662 req, 3663 metadata=self.parent.get_metadata( 3664 'PeeringGroupPeers.Create', req), 3665 timeout=t) 3666 except Exception as e: 3667 if self.parent.shouldRetry(tries, e, deadline): 3668 tries += 1 3669 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3670 continue 3671 raise plumbing.convert_error_to_porcelain(e) from e 3672 break 3673 3674 resp = models.PeeringGroupPeerCreateResponse() 3675 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3676 plumbing_response.meta) 3677 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3678 plumbing_response.peering_group_peer) 3679 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3680 plumbing_response.rate_limit) 3681 return resp 3682 3683 def delete(self, id, timeout=None): 3684 ''' 3685 Delete unlinks two peering groups. 3686 ''' 3687 deadline = None if timeout is None else time.time() + timeout 3688 req = PeeringGroupPeerDeleteRequest() 3689 3690 req.id = (id) 3691 tries = 0 3692 plumbing_response = None 3693 while True: 3694 t = None if deadline is None else deadline - time.time() 3695 try: 3696 plumbing_response = self.stub.Delete( 3697 req, 3698 metadata=self.parent.get_metadata( 3699 'PeeringGroupPeers.Delete', req), 3700 timeout=t) 3701 except Exception as e: 3702 if self.parent.shouldRetry(tries, e, deadline): 3703 tries += 1 3704 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3705 continue 3706 raise plumbing.convert_error_to_porcelain(e) from e 3707 break 3708 3709 resp = models.PeeringGroupPeerDeleteResponse() 3710 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3711 plumbing_response.meta) 3712 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3713 plumbing_response.rate_limit) 3714 return resp 3715 3716 def get(self, id, timeout=None): 3717 ''' 3718 Get reads the information of one peering group link. 3719 ''' 3720 deadline = None if timeout is None else time.time() + timeout 3721 req = PeeringGroupPeerGetRequest() 3722 if self.parent.snapshot_datetime is not None: 3723 req.meta.CopyFrom(GetRequestMetadata()) 3724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3725 3726 req.id = (id) 3727 tries = 0 3728 plumbing_response = None 3729 while True: 3730 t = None if deadline is None else deadline - time.time() 3731 try: 3732 plumbing_response = self.stub.Get( 3733 req, 3734 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3735 req), 3736 timeout=t) 3737 except Exception as e: 3738 if self.parent.shouldRetry(tries, e, deadline): 3739 tries += 1 3740 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3741 continue 3742 raise plumbing.convert_error_to_porcelain(e) from e 3743 break 3744 3745 resp = models.PeeringGroupPeerGetResponse() 3746 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3747 plumbing_response.meta) 3748 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3749 plumbing_response.peering_group_peer) 3750 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3751 plumbing_response.rate_limit) 3752 return resp 3753 3754 def list(self, filter, *args, timeout=None): 3755 ''' 3756 List gets a list of peering group links. 3757 ''' 3758 deadline = None if timeout is None else time.time() + timeout 3759 req = PeeringGroupPeerListRequest() 3760 req.meta.CopyFrom(ListRequestMetadata()) 3761 if self.parent.page_limit > 0: 3762 req.meta.limit = self.parent.page_limit 3763 if self.parent.snapshot_datetime is not None: 3764 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3765 3766 req.filter = plumbing.quote_filter_args(filter, *args) 3767 3768 def generator(svc, req): 3769 tries = 0 3770 while True: 3771 t = None if deadline is None else deadline - time.time() 3772 try: 3773 plumbing_response = svc.stub.List( 3774 req, 3775 metadata=svc.parent.get_metadata( 3776 'PeeringGroupPeers.List', req), 3777 timeout=t) 3778 except Exception as e: 3779 if self.parent.shouldRetry(tries, e, deadline): 3780 tries += 1 3781 time.sleep( 3782 self.parent.exponentialBackoff(tries, deadline)) 3783 continue 3784 raise plumbing.convert_error_to_porcelain(e) from e 3785 tries = 0 3786 for plumbing_item in plumbing_response.peering_group_peers: 3787 yield plumbing.convert_peering_group_peer_to_porcelain( 3788 plumbing_item) 3789 if plumbing_response.meta.next_cursor == '': 3790 break 3791 req.meta.cursor = plumbing_response.meta.next_cursor 3792 3793 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)
3645 def create(self, peering_group_peer, timeout=None): 3646 ''' 3647 Create links two peering groups. 3648 ''' 3649 deadline = None if timeout is None else time.time() + timeout 3650 req = PeeringGroupPeerCreateRequest() 3651 3652 if peering_group_peer is not None: 3653 req.peering_group_peer.CopyFrom( 3654 plumbing.convert_peering_group_peer_to_plumbing( 3655 peering_group_peer)) 3656 tries = 0 3657 plumbing_response = None 3658 while True: 3659 t = None if deadline is None else deadline - time.time() 3660 try: 3661 plumbing_response = self.stub.Create( 3662 req, 3663 metadata=self.parent.get_metadata( 3664 'PeeringGroupPeers.Create', req), 3665 timeout=t) 3666 except Exception as e: 3667 if self.parent.shouldRetry(tries, e, deadline): 3668 tries += 1 3669 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3670 continue 3671 raise plumbing.convert_error_to_porcelain(e) from e 3672 break 3673 3674 resp = models.PeeringGroupPeerCreateResponse() 3675 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3676 plumbing_response.meta) 3677 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3678 plumbing_response.peering_group_peer) 3679 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3680 plumbing_response.rate_limit) 3681 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
3683 def delete(self, id, timeout=None): 3684 ''' 3685 Delete unlinks two peering groups. 3686 ''' 3687 deadline = None if timeout is None else time.time() + timeout 3688 req = PeeringGroupPeerDeleteRequest() 3689 3690 req.id = (id) 3691 tries = 0 3692 plumbing_response = None 3693 while True: 3694 t = None if deadline is None else deadline - time.time() 3695 try: 3696 plumbing_response = self.stub.Delete( 3697 req, 3698 metadata=self.parent.get_metadata( 3699 'PeeringGroupPeers.Delete', req), 3700 timeout=t) 3701 except Exception as e: 3702 if self.parent.shouldRetry(tries, e, deadline): 3703 tries += 1 3704 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3705 continue 3706 raise plumbing.convert_error_to_porcelain(e) from e 3707 break 3708 3709 resp = models.PeeringGroupPeerDeleteResponse() 3710 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3711 plumbing_response.meta) 3712 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3713 plumbing_response.rate_limit) 3714 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
3716 def get(self, id, timeout=None): 3717 ''' 3718 Get reads the information of one peering group link. 3719 ''' 3720 deadline = None if timeout is None else time.time() + timeout 3721 req = PeeringGroupPeerGetRequest() 3722 if self.parent.snapshot_datetime is not None: 3723 req.meta.CopyFrom(GetRequestMetadata()) 3724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3725 3726 req.id = (id) 3727 tries = 0 3728 plumbing_response = None 3729 while True: 3730 t = None if deadline is None else deadline - time.time() 3731 try: 3732 plumbing_response = self.stub.Get( 3733 req, 3734 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3735 req), 3736 timeout=t) 3737 except Exception as e: 3738 if self.parent.shouldRetry(tries, e, deadline): 3739 tries += 1 3740 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3741 continue 3742 raise plumbing.convert_error_to_porcelain(e) from e 3743 break 3744 3745 resp = models.PeeringGroupPeerGetResponse() 3746 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3747 plumbing_response.meta) 3748 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3749 plumbing_response.peering_group_peer) 3750 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3751 plumbing_response.rate_limit) 3752 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
3754 def list(self, filter, *args, timeout=None): 3755 ''' 3756 List gets a list of peering group links. 3757 ''' 3758 deadline = None if timeout is None else time.time() + timeout 3759 req = PeeringGroupPeerListRequest() 3760 req.meta.CopyFrom(ListRequestMetadata()) 3761 if self.parent.page_limit > 0: 3762 req.meta.limit = self.parent.page_limit 3763 if self.parent.snapshot_datetime is not None: 3764 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3765 3766 req.filter = plumbing.quote_filter_args(filter, *args) 3767 3768 def generator(svc, req): 3769 tries = 0 3770 while True: 3771 t = None if deadline is None else deadline - time.time() 3772 try: 3773 plumbing_response = svc.stub.List( 3774 req, 3775 metadata=svc.parent.get_metadata( 3776 'PeeringGroupPeers.List', req), 3777 timeout=t) 3778 except Exception as e: 3779 if self.parent.shouldRetry(tries, e, deadline): 3780 tries += 1 3781 time.sleep( 3782 self.parent.exponentialBackoff(tries, deadline)) 3783 continue 3784 raise plumbing.convert_error_to_porcelain(e) from e 3785 tries = 0 3786 for plumbing_item in plumbing_response.peering_group_peers: 3787 yield plumbing.convert_peering_group_peer_to_porcelain( 3788 plumbing_item) 3789 if plumbing_response.meta.next_cursor == '': 3790 break 3791 req.meta.cursor = plumbing_response.meta.next_cursor 3792 3793 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
3796class PeeringGroupResources: 3797 ''' 3798 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 3799 See `strongdm.models.PeeringGroupResource`. 3800 ''' 3801 def __init__(self, channel, client): 3802 self.parent = client 3803 self.stub = PeeringGroupResourcesStub(channel) 3804 3805 def create(self, peering_group_resource, timeout=None): 3806 ''' 3807 Create attaches a Resource to a PeeringGroup 3808 ''' 3809 deadline = None if timeout is None else time.time() + timeout 3810 req = PeeringGroupResourceCreateRequest() 3811 3812 if peering_group_resource is not None: 3813 req.peering_group_resource.CopyFrom( 3814 plumbing.convert_peering_group_resource_to_plumbing( 3815 peering_group_resource)) 3816 tries = 0 3817 plumbing_response = None 3818 while True: 3819 t = None if deadline is None else deadline - time.time() 3820 try: 3821 plumbing_response = self.stub.Create( 3822 req, 3823 metadata=self.parent.get_metadata( 3824 'PeeringGroupResources.Create', req), 3825 timeout=t) 3826 except Exception as e: 3827 if self.parent.shouldRetry(tries, e, deadline): 3828 tries += 1 3829 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3830 continue 3831 raise plumbing.convert_error_to_porcelain(e) from e 3832 break 3833 3834 resp = models.PeeringGroupResourceCreateResponse() 3835 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3836 plumbing_response.meta) 3837 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3838 plumbing_response.peering_group_resource) 3839 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3840 plumbing_response.rate_limit) 3841 return resp 3842 3843 def delete(self, id, timeout=None): 3844 ''' 3845 Delete detaches a Resource to a PeeringGroup 3846 ''' 3847 deadline = None if timeout is None else time.time() + timeout 3848 req = PeeringGroupResourceDeleteRequest() 3849 3850 req.id = (id) 3851 tries = 0 3852 plumbing_response = None 3853 while True: 3854 t = None if deadline is None else deadline - time.time() 3855 try: 3856 plumbing_response = self.stub.Delete( 3857 req, 3858 metadata=self.parent.get_metadata( 3859 'PeeringGroupResources.Delete', req), 3860 timeout=t) 3861 except Exception as e: 3862 if self.parent.shouldRetry(tries, e, deadline): 3863 tries += 1 3864 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3865 continue 3866 raise plumbing.convert_error_to_porcelain(e) from e 3867 break 3868 3869 resp = models.PeeringGroupResourceDeleteResponse() 3870 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3871 plumbing_response.meta) 3872 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3873 plumbing_response.rate_limit) 3874 return resp 3875 3876 def get(self, id, timeout=None): 3877 ''' 3878 Get reads the information of one peering group to resource attachment. 3879 ''' 3880 deadline = None if timeout is None else time.time() + timeout 3881 req = PeeringGroupResourceGetRequest() 3882 if self.parent.snapshot_datetime is not None: 3883 req.meta.CopyFrom(GetRequestMetadata()) 3884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3885 3886 req.id = (id) 3887 tries = 0 3888 plumbing_response = None 3889 while True: 3890 t = None if deadline is None else deadline - time.time() 3891 try: 3892 plumbing_response = self.stub.Get( 3893 req, 3894 metadata=self.parent.get_metadata( 3895 'PeeringGroupResources.Get', req), 3896 timeout=t) 3897 except Exception as e: 3898 if self.parent.shouldRetry(tries, e, deadline): 3899 tries += 1 3900 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3901 continue 3902 raise plumbing.convert_error_to_porcelain(e) from e 3903 break 3904 3905 resp = models.PeeringGroupResourceGetResponse() 3906 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3907 plumbing_response.meta) 3908 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3909 plumbing_response.peering_group_resource) 3910 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3911 plumbing_response.rate_limit) 3912 return resp 3913 3914 def list(self, filter, *args, timeout=None): 3915 ''' 3916 List gets a list of peering group resource attachments. 3917 ''' 3918 deadline = None if timeout is None else time.time() + timeout 3919 req = PeeringGroupResourceListRequest() 3920 req.meta.CopyFrom(ListRequestMetadata()) 3921 if self.parent.page_limit > 0: 3922 req.meta.limit = self.parent.page_limit 3923 if self.parent.snapshot_datetime is not None: 3924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3925 3926 req.filter = plumbing.quote_filter_args(filter, *args) 3927 3928 def generator(svc, req): 3929 tries = 0 3930 while True: 3931 t = None if deadline is None else deadline - time.time() 3932 try: 3933 plumbing_response = svc.stub.List( 3934 req, 3935 metadata=svc.parent.get_metadata( 3936 'PeeringGroupResources.List', req), 3937 timeout=t) 3938 except Exception as e: 3939 if self.parent.shouldRetry(tries, e, deadline): 3940 tries += 1 3941 time.sleep( 3942 self.parent.exponentialBackoff(tries, deadline)) 3943 continue 3944 raise plumbing.convert_error_to_porcelain(e) from e 3945 tries = 0 3946 for plumbing_item in plumbing_response.peering_group_resources: 3947 yield plumbing.convert_peering_group_resource_to_porcelain( 3948 plumbing_item) 3949 if plumbing_response.meta.next_cursor == '': 3950 break 3951 req.meta.cursor = plumbing_response.meta.next_cursor 3952 3953 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)
3805 def create(self, peering_group_resource, timeout=None): 3806 ''' 3807 Create attaches a Resource to a PeeringGroup 3808 ''' 3809 deadline = None if timeout is None else time.time() + timeout 3810 req = PeeringGroupResourceCreateRequest() 3811 3812 if peering_group_resource is not None: 3813 req.peering_group_resource.CopyFrom( 3814 plumbing.convert_peering_group_resource_to_plumbing( 3815 peering_group_resource)) 3816 tries = 0 3817 plumbing_response = None 3818 while True: 3819 t = None if deadline is None else deadline - time.time() 3820 try: 3821 plumbing_response = self.stub.Create( 3822 req, 3823 metadata=self.parent.get_metadata( 3824 'PeeringGroupResources.Create', req), 3825 timeout=t) 3826 except Exception as e: 3827 if self.parent.shouldRetry(tries, e, deadline): 3828 tries += 1 3829 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3830 continue 3831 raise plumbing.convert_error_to_porcelain(e) from e 3832 break 3833 3834 resp = models.PeeringGroupResourceCreateResponse() 3835 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3836 plumbing_response.meta) 3837 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3838 plumbing_response.peering_group_resource) 3839 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3840 plumbing_response.rate_limit) 3841 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
3843 def delete(self, id, timeout=None): 3844 ''' 3845 Delete detaches a Resource to a PeeringGroup 3846 ''' 3847 deadline = None if timeout is None else time.time() + timeout 3848 req = PeeringGroupResourceDeleteRequest() 3849 3850 req.id = (id) 3851 tries = 0 3852 plumbing_response = None 3853 while True: 3854 t = None if deadline is None else deadline - time.time() 3855 try: 3856 plumbing_response = self.stub.Delete( 3857 req, 3858 metadata=self.parent.get_metadata( 3859 'PeeringGroupResources.Delete', req), 3860 timeout=t) 3861 except Exception as e: 3862 if self.parent.shouldRetry(tries, e, deadline): 3863 tries += 1 3864 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3865 continue 3866 raise plumbing.convert_error_to_porcelain(e) from e 3867 break 3868 3869 resp = models.PeeringGroupResourceDeleteResponse() 3870 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3871 plumbing_response.meta) 3872 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3873 plumbing_response.rate_limit) 3874 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
3876 def get(self, id, timeout=None): 3877 ''' 3878 Get reads the information of one peering group to resource attachment. 3879 ''' 3880 deadline = None if timeout is None else time.time() + timeout 3881 req = PeeringGroupResourceGetRequest() 3882 if self.parent.snapshot_datetime is not None: 3883 req.meta.CopyFrom(GetRequestMetadata()) 3884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3885 3886 req.id = (id) 3887 tries = 0 3888 plumbing_response = None 3889 while True: 3890 t = None if deadline is None else deadline - time.time() 3891 try: 3892 plumbing_response = self.stub.Get( 3893 req, 3894 metadata=self.parent.get_metadata( 3895 'PeeringGroupResources.Get', req), 3896 timeout=t) 3897 except Exception as e: 3898 if self.parent.shouldRetry(tries, e, deadline): 3899 tries += 1 3900 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3901 continue 3902 raise plumbing.convert_error_to_porcelain(e) from e 3903 break 3904 3905 resp = models.PeeringGroupResourceGetResponse() 3906 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3907 plumbing_response.meta) 3908 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3909 plumbing_response.peering_group_resource) 3910 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3911 plumbing_response.rate_limit) 3912 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
3914 def list(self, filter, *args, timeout=None): 3915 ''' 3916 List gets a list of peering group resource attachments. 3917 ''' 3918 deadline = None if timeout is None else time.time() + timeout 3919 req = PeeringGroupResourceListRequest() 3920 req.meta.CopyFrom(ListRequestMetadata()) 3921 if self.parent.page_limit > 0: 3922 req.meta.limit = self.parent.page_limit 3923 if self.parent.snapshot_datetime is not None: 3924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3925 3926 req.filter = plumbing.quote_filter_args(filter, *args) 3927 3928 def generator(svc, req): 3929 tries = 0 3930 while True: 3931 t = None if deadline is None else deadline - time.time() 3932 try: 3933 plumbing_response = svc.stub.List( 3934 req, 3935 metadata=svc.parent.get_metadata( 3936 'PeeringGroupResources.List', req), 3937 timeout=t) 3938 except Exception as e: 3939 if self.parent.shouldRetry(tries, e, deadline): 3940 tries += 1 3941 time.sleep( 3942 self.parent.exponentialBackoff(tries, deadline)) 3943 continue 3944 raise plumbing.convert_error_to_porcelain(e) from e 3945 tries = 0 3946 for plumbing_item in plumbing_response.peering_group_resources: 3947 yield plumbing.convert_peering_group_resource_to_porcelain( 3948 plumbing_item) 3949 if plumbing_response.meta.next_cursor == '': 3950 break 3951 req.meta.cursor = plumbing_response.meta.next_cursor 3952 3953 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
3956class PeeringGroups: 3957 ''' 3958 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 3959 See `strongdm.models.PeeringGroup`. 3960 ''' 3961 def __init__(self, channel, client): 3962 self.parent = client 3963 self.stub = PeeringGroupsStub(channel) 3964 3965 def create(self, peering_group, timeout=None): 3966 ''' 3967 Create registers a new PeeringGroup. 3968 ''' 3969 deadline = None if timeout is None else time.time() + timeout 3970 req = PeeringGroupCreateRequest() 3971 3972 if peering_group is not None: 3973 req.peering_group.CopyFrom( 3974 plumbing.convert_peering_group_to_plumbing(peering_group)) 3975 tries = 0 3976 plumbing_response = None 3977 while True: 3978 t = None if deadline is None else deadline - time.time() 3979 try: 3980 plumbing_response = self.stub.Create( 3981 req, 3982 metadata=self.parent.get_metadata('PeeringGroups.Create', 3983 req), 3984 timeout=t) 3985 except Exception as e: 3986 if self.parent.shouldRetry(tries, e, deadline): 3987 tries += 1 3988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3989 continue 3990 raise plumbing.convert_error_to_porcelain(e) from e 3991 break 3992 3993 resp = models.PeeringGroupCreateResponse() 3994 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3995 plumbing_response.meta) 3996 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3997 plumbing_response.peering_group) 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp 4001 4002 def delete(self, id, timeout=None): 4003 ''' 4004 Delete removes a PeeringGroup by ID. 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = PeeringGroupDeleteRequest() 4008 4009 req.id = (id) 4010 tries = 0 4011 plumbing_response = None 4012 while True: 4013 t = None if deadline is None else deadline - time.time() 4014 try: 4015 plumbing_response = self.stub.Delete( 4016 req, 4017 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4018 req), 4019 timeout=t) 4020 except Exception as e: 4021 if self.parent.shouldRetry(tries, e, deadline): 4022 tries += 1 4023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4024 continue 4025 raise plumbing.convert_error_to_porcelain(e) from e 4026 break 4027 4028 resp = models.PeeringGroupDeleteResponse() 4029 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4030 plumbing_response.meta) 4031 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4032 plumbing_response.rate_limit) 4033 return resp 4034 4035 def get(self, id, timeout=None): 4036 ''' 4037 Get reads one PeeringGroup by ID. It will load all its dependencies. 4038 ''' 4039 deadline = None if timeout is None else time.time() + timeout 4040 req = PeeringGroupGetRequest() 4041 if self.parent.snapshot_datetime is not None: 4042 req.meta.CopyFrom(GetRequestMetadata()) 4043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4044 4045 req.id = (id) 4046 tries = 0 4047 plumbing_response = None 4048 while True: 4049 t = None if deadline is None else deadline - time.time() 4050 try: 4051 plumbing_response = self.stub.Get( 4052 req, 4053 metadata=self.parent.get_metadata('PeeringGroups.Get', 4054 req), 4055 timeout=t) 4056 except Exception as e: 4057 if self.parent.shouldRetry(tries, e, deadline): 4058 tries += 1 4059 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4060 continue 4061 raise plumbing.convert_error_to_porcelain(e) from e 4062 break 4063 4064 resp = models.PeeringGroupGetResponse() 4065 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4066 plumbing_response.meta) 4067 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4068 plumbing_response.peering_group) 4069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4070 plumbing_response.rate_limit) 4071 return resp 4072 4073 def list(self, filter, *args, timeout=None): 4074 ''' 4075 List gets a list of Peering Groups. 4076 ''' 4077 deadline = None if timeout is None else time.time() + timeout 4078 req = PeeringGroupListRequest() 4079 req.meta.CopyFrom(ListRequestMetadata()) 4080 if self.parent.page_limit > 0: 4081 req.meta.limit = self.parent.page_limit 4082 if self.parent.snapshot_datetime is not None: 4083 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4084 4085 req.filter = plumbing.quote_filter_args(filter, *args) 4086 4087 def generator(svc, req): 4088 tries = 0 4089 while True: 4090 t = None if deadline is None else deadline - time.time() 4091 try: 4092 plumbing_response = svc.stub.List( 4093 req, 4094 metadata=svc.parent.get_metadata( 4095 'PeeringGroups.List', req), 4096 timeout=t) 4097 except Exception as e: 4098 if self.parent.shouldRetry(tries, e, deadline): 4099 tries += 1 4100 time.sleep( 4101 self.parent.exponentialBackoff(tries, deadline)) 4102 continue 4103 raise plumbing.convert_error_to_porcelain(e) from e 4104 tries = 0 4105 for plumbing_item in plumbing_response.peering_groups: 4106 yield plumbing.convert_peering_group_to_porcelain( 4107 plumbing_item) 4108 if plumbing_response.meta.next_cursor == '': 4109 break 4110 req.meta.cursor = plumbing_response.meta.next_cursor 4111 4112 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)
3965 def create(self, peering_group, timeout=None): 3966 ''' 3967 Create registers a new PeeringGroup. 3968 ''' 3969 deadline = None if timeout is None else time.time() + timeout 3970 req = PeeringGroupCreateRequest() 3971 3972 if peering_group is not None: 3973 req.peering_group.CopyFrom( 3974 plumbing.convert_peering_group_to_plumbing(peering_group)) 3975 tries = 0 3976 plumbing_response = None 3977 while True: 3978 t = None if deadline is None else deadline - time.time() 3979 try: 3980 plumbing_response = self.stub.Create( 3981 req, 3982 metadata=self.parent.get_metadata('PeeringGroups.Create', 3983 req), 3984 timeout=t) 3985 except Exception as e: 3986 if self.parent.shouldRetry(tries, e, deadline): 3987 tries += 1 3988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3989 continue 3990 raise plumbing.convert_error_to_porcelain(e) from e 3991 break 3992 3993 resp = models.PeeringGroupCreateResponse() 3994 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3995 plumbing_response.meta) 3996 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3997 plumbing_response.peering_group) 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
4002 def delete(self, id, timeout=None): 4003 ''' 4004 Delete removes a PeeringGroup by ID. 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = PeeringGroupDeleteRequest() 4008 4009 req.id = (id) 4010 tries = 0 4011 plumbing_response = None 4012 while True: 4013 t = None if deadline is None else deadline - time.time() 4014 try: 4015 plumbing_response = self.stub.Delete( 4016 req, 4017 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4018 req), 4019 timeout=t) 4020 except Exception as e: 4021 if self.parent.shouldRetry(tries, e, deadline): 4022 tries += 1 4023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4024 continue 4025 raise plumbing.convert_error_to_porcelain(e) from e 4026 break 4027 4028 resp = models.PeeringGroupDeleteResponse() 4029 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4030 plumbing_response.meta) 4031 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4032 plumbing_response.rate_limit) 4033 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
4035 def get(self, id, timeout=None): 4036 ''' 4037 Get reads one PeeringGroup by ID. It will load all its dependencies. 4038 ''' 4039 deadline = None if timeout is None else time.time() + timeout 4040 req = PeeringGroupGetRequest() 4041 if self.parent.snapshot_datetime is not None: 4042 req.meta.CopyFrom(GetRequestMetadata()) 4043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4044 4045 req.id = (id) 4046 tries = 0 4047 plumbing_response = None 4048 while True: 4049 t = None if deadline is None else deadline - time.time() 4050 try: 4051 plumbing_response = self.stub.Get( 4052 req, 4053 metadata=self.parent.get_metadata('PeeringGroups.Get', 4054 req), 4055 timeout=t) 4056 except Exception as e: 4057 if self.parent.shouldRetry(tries, e, deadline): 4058 tries += 1 4059 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4060 continue 4061 raise plumbing.convert_error_to_porcelain(e) from e 4062 break 4063 4064 resp = models.PeeringGroupGetResponse() 4065 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4066 plumbing_response.meta) 4067 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4068 plumbing_response.peering_group) 4069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4070 plumbing_response.rate_limit) 4071 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
4073 def list(self, filter, *args, timeout=None): 4074 ''' 4075 List gets a list of Peering Groups. 4076 ''' 4077 deadline = None if timeout is None else time.time() + timeout 4078 req = PeeringGroupListRequest() 4079 req.meta.CopyFrom(ListRequestMetadata()) 4080 if self.parent.page_limit > 0: 4081 req.meta.limit = self.parent.page_limit 4082 if self.parent.snapshot_datetime is not None: 4083 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4084 4085 req.filter = plumbing.quote_filter_args(filter, *args) 4086 4087 def generator(svc, req): 4088 tries = 0 4089 while True: 4090 t = None if deadline is None else deadline - time.time() 4091 try: 4092 plumbing_response = svc.stub.List( 4093 req, 4094 metadata=svc.parent.get_metadata( 4095 'PeeringGroups.List', req), 4096 timeout=t) 4097 except Exception as e: 4098 if self.parent.shouldRetry(tries, e, deadline): 4099 tries += 1 4100 time.sleep( 4101 self.parent.exponentialBackoff(tries, deadline)) 4102 continue 4103 raise plumbing.convert_error_to_porcelain(e) from e 4104 tries = 0 4105 for plumbing_item in plumbing_response.peering_groups: 4106 yield plumbing.convert_peering_group_to_porcelain( 4107 plumbing_item) 4108 if plumbing_response.meta.next_cursor == '': 4109 break 4110 req.meta.cursor = plumbing_response.meta.next_cursor 4111 4112 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
4115class Policies: 4116 ''' 4117 Policies are the collection of one or more statements that enforce fine-grained access 4118 control for the users of an organization. 4119 See `strongdm.models.Policy`. 4120 ''' 4121 def __init__(self, channel, client): 4122 self.parent = client 4123 self.stub = PoliciesStub(channel) 4124 4125 def create(self, policy, timeout=None): 4126 ''' 4127 Create creates a new Policy. 4128 ''' 4129 deadline = None if timeout is None else time.time() + timeout 4130 req = PolicyCreateRequest() 4131 4132 if policy is not None: 4133 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4134 tries = 0 4135 plumbing_response = None 4136 while True: 4137 t = None if deadline is None else deadline - time.time() 4138 try: 4139 plumbing_response = self.stub.Create( 4140 req, 4141 metadata=self.parent.get_metadata('Policies.Create', req), 4142 timeout=t) 4143 except Exception as e: 4144 if self.parent.shouldRetry(tries, e, deadline): 4145 tries += 1 4146 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4147 continue 4148 raise plumbing.convert_error_to_porcelain(e) from e 4149 break 4150 4151 resp = models.PolicyCreateResponse() 4152 resp.policy = plumbing.convert_policy_to_porcelain( 4153 plumbing_response.policy) 4154 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4155 plumbing_response.rate_limit) 4156 return resp 4157 4158 def delete(self, id, timeout=None): 4159 ''' 4160 Delete removes a Policy by ID. 4161 ''' 4162 deadline = None if timeout is None else time.time() + timeout 4163 req = PolicyDeleteRequest() 4164 4165 req.id = (id) 4166 tries = 0 4167 plumbing_response = None 4168 while True: 4169 t = None if deadline is None else deadline - time.time() 4170 try: 4171 plumbing_response = self.stub.Delete( 4172 req, 4173 metadata=self.parent.get_metadata('Policies.Delete', req), 4174 timeout=t) 4175 except Exception as e: 4176 if self.parent.shouldRetry(tries, e, deadline): 4177 tries += 1 4178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4179 continue 4180 raise plumbing.convert_error_to_porcelain(e) from e 4181 break 4182 4183 resp = models.PolicyDeleteResponse() 4184 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4185 plumbing_response.rate_limit) 4186 return resp 4187 4188 def update(self, policy, timeout=None): 4189 ''' 4190 Update replaces all the fields of a Policy by ID. 4191 ''' 4192 deadline = None if timeout is None else time.time() + timeout 4193 req = PolicyUpdateRequest() 4194 4195 if policy is not None: 4196 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4197 tries = 0 4198 plumbing_response = None 4199 while True: 4200 t = None if deadline is None else deadline - time.time() 4201 try: 4202 plumbing_response = self.stub.Update( 4203 req, 4204 metadata=self.parent.get_metadata('Policies.Update', req), 4205 timeout=t) 4206 except Exception as e: 4207 if self.parent.shouldRetry(tries, e, deadline): 4208 tries += 1 4209 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4210 continue 4211 raise plumbing.convert_error_to_porcelain(e) from e 4212 break 4213 4214 resp = models.PolicyUpdateResponse() 4215 resp.policy = plumbing.convert_policy_to_porcelain( 4216 plumbing_response.policy) 4217 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4218 plumbing_response.rate_limit) 4219 return resp 4220 4221 def get(self, id, timeout=None): 4222 ''' 4223 Get reads one Policy by ID. 4224 ''' 4225 deadline = None if timeout is None else time.time() + timeout 4226 req = PolicyGetRequest() 4227 if self.parent.snapshot_datetime is not None: 4228 req.meta.CopyFrom(GetRequestMetadata()) 4229 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4230 4231 req.id = (id) 4232 tries = 0 4233 plumbing_response = None 4234 while True: 4235 t = None if deadline is None else deadline - time.time() 4236 try: 4237 plumbing_response = self.stub.Get( 4238 req, 4239 metadata=self.parent.get_metadata('Policies.Get', req), 4240 timeout=t) 4241 except Exception as e: 4242 if self.parent.shouldRetry(tries, e, deadline): 4243 tries += 1 4244 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4245 continue 4246 raise plumbing.convert_error_to_porcelain(e) from e 4247 break 4248 4249 resp = models.PolicyGetResponse() 4250 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4251 plumbing_response.meta) 4252 resp.policy = plumbing.convert_policy_to_porcelain( 4253 plumbing_response.policy) 4254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4255 plumbing_response.rate_limit) 4256 return resp 4257 4258 def list(self, filter, *args, timeout=None): 4259 ''' 4260 List gets a list of Policy matching a given set of criteria 4261 ''' 4262 deadline = None if timeout is None else time.time() + timeout 4263 req = PolicyListRequest() 4264 req.meta.CopyFrom(ListRequestMetadata()) 4265 if self.parent.page_limit > 0: 4266 req.meta.limit = self.parent.page_limit 4267 if self.parent.snapshot_datetime is not None: 4268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4269 4270 req.filter = plumbing.quote_filter_args(filter, *args) 4271 4272 def generator(svc, req): 4273 tries = 0 4274 while True: 4275 t = None if deadline is None else deadline - time.time() 4276 try: 4277 plumbing_response = svc.stub.List( 4278 req, 4279 metadata=svc.parent.get_metadata('Policies.List', req), 4280 timeout=t) 4281 except Exception as e: 4282 if self.parent.shouldRetry(tries, e, deadline): 4283 tries += 1 4284 time.sleep( 4285 self.parent.exponentialBackoff(tries, deadline)) 4286 continue 4287 raise plumbing.convert_error_to_porcelain(e) from e 4288 tries = 0 4289 for plumbing_item in plumbing_response.policies: 4290 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4291 if plumbing_response.meta.next_cursor == '': 4292 break 4293 req.meta.cursor = plumbing_response.meta.next_cursor 4294 4295 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)
4125 def create(self, policy, timeout=None): 4126 ''' 4127 Create creates a new Policy. 4128 ''' 4129 deadline = None if timeout is None else time.time() + timeout 4130 req = PolicyCreateRequest() 4131 4132 if policy is not None: 4133 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4134 tries = 0 4135 plumbing_response = None 4136 while True: 4137 t = None if deadline is None else deadline - time.time() 4138 try: 4139 plumbing_response = self.stub.Create( 4140 req, 4141 metadata=self.parent.get_metadata('Policies.Create', req), 4142 timeout=t) 4143 except Exception as e: 4144 if self.parent.shouldRetry(tries, e, deadline): 4145 tries += 1 4146 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4147 continue 4148 raise plumbing.convert_error_to_porcelain(e) from e 4149 break 4150 4151 resp = models.PolicyCreateResponse() 4152 resp.policy = plumbing.convert_policy_to_porcelain( 4153 plumbing_response.policy) 4154 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4155 plumbing_response.rate_limit) 4156 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
4158 def delete(self, id, timeout=None): 4159 ''' 4160 Delete removes a Policy by ID. 4161 ''' 4162 deadline = None if timeout is None else time.time() + timeout 4163 req = PolicyDeleteRequest() 4164 4165 req.id = (id) 4166 tries = 0 4167 plumbing_response = None 4168 while True: 4169 t = None if deadline is None else deadline - time.time() 4170 try: 4171 plumbing_response = self.stub.Delete( 4172 req, 4173 metadata=self.parent.get_metadata('Policies.Delete', req), 4174 timeout=t) 4175 except Exception as e: 4176 if self.parent.shouldRetry(tries, e, deadline): 4177 tries += 1 4178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4179 continue 4180 raise plumbing.convert_error_to_porcelain(e) from e 4181 break 4182 4183 resp = models.PolicyDeleteResponse() 4184 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4185 plumbing_response.rate_limit) 4186 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
4188 def update(self, policy, timeout=None): 4189 ''' 4190 Update replaces all the fields of a Policy by ID. 4191 ''' 4192 deadline = None if timeout is None else time.time() + timeout 4193 req = PolicyUpdateRequest() 4194 4195 if policy is not None: 4196 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4197 tries = 0 4198 plumbing_response = None 4199 while True: 4200 t = None if deadline is None else deadline - time.time() 4201 try: 4202 plumbing_response = self.stub.Update( 4203 req, 4204 metadata=self.parent.get_metadata('Policies.Update', req), 4205 timeout=t) 4206 except Exception as e: 4207 if self.parent.shouldRetry(tries, e, deadline): 4208 tries += 1 4209 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4210 continue 4211 raise plumbing.convert_error_to_porcelain(e) from e 4212 break 4213 4214 resp = models.PolicyUpdateResponse() 4215 resp.policy = plumbing.convert_policy_to_porcelain( 4216 plumbing_response.policy) 4217 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4218 plumbing_response.rate_limit) 4219 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
4221 def get(self, id, timeout=None): 4222 ''' 4223 Get reads one Policy by ID. 4224 ''' 4225 deadline = None if timeout is None else time.time() + timeout 4226 req = PolicyGetRequest() 4227 if self.parent.snapshot_datetime is not None: 4228 req.meta.CopyFrom(GetRequestMetadata()) 4229 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4230 4231 req.id = (id) 4232 tries = 0 4233 plumbing_response = None 4234 while True: 4235 t = None if deadline is None else deadline - time.time() 4236 try: 4237 plumbing_response = self.stub.Get( 4238 req, 4239 metadata=self.parent.get_metadata('Policies.Get', req), 4240 timeout=t) 4241 except Exception as e: 4242 if self.parent.shouldRetry(tries, e, deadline): 4243 tries += 1 4244 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4245 continue 4246 raise plumbing.convert_error_to_porcelain(e) from e 4247 break 4248 4249 resp = models.PolicyGetResponse() 4250 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4251 plumbing_response.meta) 4252 resp.policy = plumbing.convert_policy_to_porcelain( 4253 plumbing_response.policy) 4254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4255 plumbing_response.rate_limit) 4256 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
4258 def list(self, filter, *args, timeout=None): 4259 ''' 4260 List gets a list of Policy matching a given set of criteria 4261 ''' 4262 deadline = None if timeout is None else time.time() + timeout 4263 req = PolicyListRequest() 4264 req.meta.CopyFrom(ListRequestMetadata()) 4265 if self.parent.page_limit > 0: 4266 req.meta.limit = self.parent.page_limit 4267 if self.parent.snapshot_datetime is not None: 4268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4269 4270 req.filter = plumbing.quote_filter_args(filter, *args) 4271 4272 def generator(svc, req): 4273 tries = 0 4274 while True: 4275 t = None if deadline is None else deadline - time.time() 4276 try: 4277 plumbing_response = svc.stub.List( 4278 req, 4279 metadata=svc.parent.get_metadata('Policies.List', req), 4280 timeout=t) 4281 except Exception as e: 4282 if self.parent.shouldRetry(tries, e, deadline): 4283 tries += 1 4284 time.sleep( 4285 self.parent.exponentialBackoff(tries, deadline)) 4286 continue 4287 raise plumbing.convert_error_to_porcelain(e) from e 4288 tries = 0 4289 for plumbing_item in plumbing_response.policies: 4290 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4291 if plumbing_response.meta.next_cursor == '': 4292 break 4293 req.meta.cursor = plumbing_response.meta.next_cursor 4294 4295 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
4298class SnapshotPolicies: 4299 ''' 4300 SnapshotPolicies exposes the read only methods of the Policies 4301 service for historical queries. 4302 ''' 4303 def __init__(self, policies): 4304 self.policies = policies 4305 4306 def get(self, id, timeout=None): 4307 ''' 4308 Get reads one Policy by ID. 4309 ''' 4310 return self.policies.get(id, timeout=timeout) 4311 4312 def list(self, filter, *args, timeout=None): 4313 ''' 4314 List gets a list of Policy matching a given set of criteria 4315 ''' 4316 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
4319class PoliciesHistory: 4320 ''' 4321 PoliciesHistory records all changes to the state of a Policy. 4322 See `strongdm.models.PolicyHistory`. 4323 ''' 4324 def __init__(self, channel, client): 4325 self.parent = client 4326 self.stub = PoliciesHistoryStub(channel) 4327 4328 def list(self, filter, *args, timeout=None): 4329 ''' 4330 List gets a list of PolicyHistory records matching a given set of criteria. 4331 ''' 4332 deadline = None if timeout is None else time.time() + timeout 4333 req = PoliciesHistoryListRequest() 4334 req.meta.CopyFrom(ListRequestMetadata()) 4335 if self.parent.page_limit > 0: 4336 req.meta.limit = self.parent.page_limit 4337 if self.parent.snapshot_datetime is not None: 4338 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4339 4340 req.filter = plumbing.quote_filter_args(filter, *args) 4341 4342 def generator(svc, req): 4343 tries = 0 4344 while True: 4345 t = None if deadline is None else deadline - time.time() 4346 try: 4347 plumbing_response = svc.stub.List( 4348 req, 4349 metadata=svc.parent.get_metadata( 4350 'PoliciesHistory.List', req), 4351 timeout=t) 4352 except Exception as e: 4353 if self.parent.shouldRetry(tries, e, deadline): 4354 tries += 1 4355 time.sleep( 4356 self.parent.exponentialBackoff(tries, deadline)) 4357 continue 4358 raise plumbing.convert_error_to_porcelain(e) from e 4359 tries = 0 4360 for plumbing_item in plumbing_response.history: 4361 yield plumbing.convert_policy_history_to_porcelain( 4362 plumbing_item) 4363 if plumbing_response.meta.next_cursor == '': 4364 break 4365 req.meta.cursor = plumbing_response.meta.next_cursor 4366 4367 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)
4328 def list(self, filter, *args, timeout=None): 4329 ''' 4330 List gets a list of PolicyHistory records matching a given set of criteria. 4331 ''' 4332 deadline = None if timeout is None else time.time() + timeout 4333 req = PoliciesHistoryListRequest() 4334 req.meta.CopyFrom(ListRequestMetadata()) 4335 if self.parent.page_limit > 0: 4336 req.meta.limit = self.parent.page_limit 4337 if self.parent.snapshot_datetime is not None: 4338 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4339 4340 req.filter = plumbing.quote_filter_args(filter, *args) 4341 4342 def generator(svc, req): 4343 tries = 0 4344 while True: 4345 t = None if deadline is None else deadline - time.time() 4346 try: 4347 plumbing_response = svc.stub.List( 4348 req, 4349 metadata=svc.parent.get_metadata( 4350 'PoliciesHistory.List', req), 4351 timeout=t) 4352 except Exception as e: 4353 if self.parent.shouldRetry(tries, e, deadline): 4354 tries += 1 4355 time.sleep( 4356 self.parent.exponentialBackoff(tries, deadline)) 4357 continue 4358 raise plumbing.convert_error_to_porcelain(e) from e 4359 tries = 0 4360 for plumbing_item in plumbing_response.history: 4361 yield plumbing.convert_policy_history_to_porcelain( 4362 plumbing_item) 4363 if plumbing_response.meta.next_cursor == '': 4364 break 4365 req.meta.cursor = plumbing_response.meta.next_cursor 4366 4367 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
4370class ProxyClusterKeys: 4371 ''' 4372 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4373 The proxies within a cluster share the same key. One cluster can have 4374 multiple keys in order to facilitate key rotation. 4375 See `strongdm.models.ProxyClusterKey`. 4376 ''' 4377 def __init__(self, channel, client): 4378 self.parent = client 4379 self.stub = ProxyClusterKeysStub(channel) 4380 4381 def create(self, proxy_cluster_key, timeout=None): 4382 ''' 4383 Create registers a new ProxyClusterKey. 4384 ''' 4385 deadline = None if timeout is None else time.time() + timeout 4386 req = ProxyClusterKeyCreateRequest() 4387 4388 if proxy_cluster_key is not None: 4389 req.proxy_cluster_key.CopyFrom( 4390 plumbing.convert_proxy_cluster_key_to_plumbing( 4391 proxy_cluster_key)) 4392 tries = 0 4393 plumbing_response = None 4394 while True: 4395 t = None if deadline is None else deadline - time.time() 4396 try: 4397 plumbing_response = self.stub.Create( 4398 req, 4399 metadata=self.parent.get_metadata( 4400 'ProxyClusterKeys.Create', req), 4401 timeout=t) 4402 except Exception as e: 4403 if self.parent.shouldRetry(tries, e, deadline): 4404 tries += 1 4405 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4406 continue 4407 raise plumbing.convert_error_to_porcelain(e) from e 4408 break 4409 4410 resp = models.ProxyClusterKeyCreateResponse() 4411 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4412 plumbing_response.meta) 4413 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4414 plumbing_response.proxy_cluster_key) 4415 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4416 plumbing_response.rate_limit) 4417 resp.secret_key = (plumbing_response.secret_key) 4418 return resp 4419 4420 def get(self, id, timeout=None): 4421 ''' 4422 Get reads one ProxyClusterKey by ID. 4423 ''' 4424 deadline = None if timeout is None else time.time() + timeout 4425 req = ProxyClusterKeyGetRequest() 4426 if self.parent.snapshot_datetime is not None: 4427 req.meta.CopyFrom(GetRequestMetadata()) 4428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4429 4430 req.id = (id) 4431 tries = 0 4432 plumbing_response = None 4433 while True: 4434 t = None if deadline is None else deadline - time.time() 4435 try: 4436 plumbing_response = self.stub.Get( 4437 req, 4438 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4439 req), 4440 timeout=t) 4441 except Exception as e: 4442 if self.parent.shouldRetry(tries, e, deadline): 4443 tries += 1 4444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4445 continue 4446 raise plumbing.convert_error_to_porcelain(e) from e 4447 break 4448 4449 resp = models.ProxyClusterKeyGetResponse() 4450 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4451 plumbing_response.meta) 4452 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4453 plumbing_response.proxy_cluster_key) 4454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4455 plumbing_response.rate_limit) 4456 return resp 4457 4458 def delete(self, id, timeout=None): 4459 ''' 4460 Delete removes a ProxyClusterKey by ID. 4461 ''' 4462 deadline = None if timeout is None else time.time() + timeout 4463 req = ProxyClusterKeyDeleteRequest() 4464 4465 req.id = (id) 4466 tries = 0 4467 plumbing_response = None 4468 while True: 4469 t = None if deadline is None else deadline - time.time() 4470 try: 4471 plumbing_response = self.stub.Delete( 4472 req, 4473 metadata=self.parent.get_metadata( 4474 'ProxyClusterKeys.Delete', req), 4475 timeout=t) 4476 except Exception as e: 4477 if self.parent.shouldRetry(tries, e, deadline): 4478 tries += 1 4479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4480 continue 4481 raise plumbing.convert_error_to_porcelain(e) from e 4482 break 4483 4484 resp = models.ProxyClusterKeyDeleteResponse() 4485 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4486 plumbing_response.meta) 4487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4488 plumbing_response.rate_limit) 4489 return resp 4490 4491 def list(self, filter, *args, timeout=None): 4492 ''' 4493 List gets a list of ProxyClusterKeys matching a given set of criteria. 4494 ''' 4495 deadline = None if timeout is None else time.time() + timeout 4496 req = ProxyClusterKeyListRequest() 4497 req.meta.CopyFrom(ListRequestMetadata()) 4498 if self.parent.page_limit > 0: 4499 req.meta.limit = self.parent.page_limit 4500 if self.parent.snapshot_datetime is not None: 4501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4502 4503 req.filter = plumbing.quote_filter_args(filter, *args) 4504 4505 def generator(svc, req): 4506 tries = 0 4507 while True: 4508 t = None if deadline is None else deadline - time.time() 4509 try: 4510 plumbing_response = svc.stub.List( 4511 req, 4512 metadata=svc.parent.get_metadata( 4513 'ProxyClusterKeys.List', req), 4514 timeout=t) 4515 except Exception as e: 4516 if self.parent.shouldRetry(tries, e, deadline): 4517 tries += 1 4518 time.sleep( 4519 self.parent.exponentialBackoff(tries, deadline)) 4520 continue 4521 raise plumbing.convert_error_to_porcelain(e) from e 4522 tries = 0 4523 for plumbing_item in plumbing_response.proxy_cluster_keys: 4524 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4525 plumbing_item) 4526 if plumbing_response.meta.next_cursor == '': 4527 break 4528 req.meta.cursor = plumbing_response.meta.next_cursor 4529 4530 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)
4381 def create(self, proxy_cluster_key, timeout=None): 4382 ''' 4383 Create registers a new ProxyClusterKey. 4384 ''' 4385 deadline = None if timeout is None else time.time() + timeout 4386 req = ProxyClusterKeyCreateRequest() 4387 4388 if proxy_cluster_key is not None: 4389 req.proxy_cluster_key.CopyFrom( 4390 plumbing.convert_proxy_cluster_key_to_plumbing( 4391 proxy_cluster_key)) 4392 tries = 0 4393 plumbing_response = None 4394 while True: 4395 t = None if deadline is None else deadline - time.time() 4396 try: 4397 plumbing_response = self.stub.Create( 4398 req, 4399 metadata=self.parent.get_metadata( 4400 'ProxyClusterKeys.Create', req), 4401 timeout=t) 4402 except Exception as e: 4403 if self.parent.shouldRetry(tries, e, deadline): 4404 tries += 1 4405 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4406 continue 4407 raise plumbing.convert_error_to_porcelain(e) from e 4408 break 4409 4410 resp = models.ProxyClusterKeyCreateResponse() 4411 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4412 plumbing_response.meta) 4413 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4414 plumbing_response.proxy_cluster_key) 4415 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4416 plumbing_response.rate_limit) 4417 resp.secret_key = (plumbing_response.secret_key) 4418 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
4420 def get(self, id, timeout=None): 4421 ''' 4422 Get reads one ProxyClusterKey by ID. 4423 ''' 4424 deadline = None if timeout is None else time.time() + timeout 4425 req = ProxyClusterKeyGetRequest() 4426 if self.parent.snapshot_datetime is not None: 4427 req.meta.CopyFrom(GetRequestMetadata()) 4428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4429 4430 req.id = (id) 4431 tries = 0 4432 plumbing_response = None 4433 while True: 4434 t = None if deadline is None else deadline - time.time() 4435 try: 4436 plumbing_response = self.stub.Get( 4437 req, 4438 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4439 req), 4440 timeout=t) 4441 except Exception as e: 4442 if self.parent.shouldRetry(tries, e, deadline): 4443 tries += 1 4444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4445 continue 4446 raise plumbing.convert_error_to_porcelain(e) from e 4447 break 4448 4449 resp = models.ProxyClusterKeyGetResponse() 4450 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4451 plumbing_response.meta) 4452 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4453 plumbing_response.proxy_cluster_key) 4454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4455 plumbing_response.rate_limit) 4456 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
4458 def delete(self, id, timeout=None): 4459 ''' 4460 Delete removes a ProxyClusterKey by ID. 4461 ''' 4462 deadline = None if timeout is None else time.time() + timeout 4463 req = ProxyClusterKeyDeleteRequest() 4464 4465 req.id = (id) 4466 tries = 0 4467 plumbing_response = None 4468 while True: 4469 t = None if deadline is None else deadline - time.time() 4470 try: 4471 plumbing_response = self.stub.Delete( 4472 req, 4473 metadata=self.parent.get_metadata( 4474 'ProxyClusterKeys.Delete', req), 4475 timeout=t) 4476 except Exception as e: 4477 if self.parent.shouldRetry(tries, e, deadline): 4478 tries += 1 4479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4480 continue 4481 raise plumbing.convert_error_to_porcelain(e) from e 4482 break 4483 4484 resp = models.ProxyClusterKeyDeleteResponse() 4485 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4486 plumbing_response.meta) 4487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4488 plumbing_response.rate_limit) 4489 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4491 def list(self, filter, *args, timeout=None): 4492 ''' 4493 List gets a list of ProxyClusterKeys matching a given set of criteria. 4494 ''' 4495 deadline = None if timeout is None else time.time() + timeout 4496 req = ProxyClusterKeyListRequest() 4497 req.meta.CopyFrom(ListRequestMetadata()) 4498 if self.parent.page_limit > 0: 4499 req.meta.limit = self.parent.page_limit 4500 if self.parent.snapshot_datetime is not None: 4501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4502 4503 req.filter = plumbing.quote_filter_args(filter, *args) 4504 4505 def generator(svc, req): 4506 tries = 0 4507 while True: 4508 t = None if deadline is None else deadline - time.time() 4509 try: 4510 plumbing_response = svc.stub.List( 4511 req, 4512 metadata=svc.parent.get_metadata( 4513 'ProxyClusterKeys.List', req), 4514 timeout=t) 4515 except Exception as e: 4516 if self.parent.shouldRetry(tries, e, deadline): 4517 tries += 1 4518 time.sleep( 4519 self.parent.exponentialBackoff(tries, deadline)) 4520 continue 4521 raise plumbing.convert_error_to_porcelain(e) from e 4522 tries = 0 4523 for plumbing_item in plumbing_response.proxy_cluster_keys: 4524 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4525 plumbing_item) 4526 if plumbing_response.meta.next_cursor == '': 4527 break 4528 req.meta.cursor = plumbing_response.meta.next_cursor 4529 4530 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
4533class SnapshotProxyClusterKeys: 4534 ''' 4535 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4536 service for historical queries. 4537 ''' 4538 def __init__(self, proxy_cluster_keys): 4539 self.proxy_cluster_keys = proxy_cluster_keys 4540 4541 def get(self, id, timeout=None): 4542 ''' 4543 Get reads one ProxyClusterKey by ID. 4544 ''' 4545 return self.proxy_cluster_keys.get(id, timeout=timeout) 4546 4547 def list(self, filter, *args, timeout=None): 4548 ''' 4549 List gets a list of ProxyClusterKeys matching a given set of criteria. 4550 ''' 4551 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)
4541 def get(self, id, timeout=None): 4542 ''' 4543 Get reads one ProxyClusterKey by ID. 4544 ''' 4545 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4547 def list(self, filter, *args, timeout=None): 4548 ''' 4549 List gets a list of ProxyClusterKeys matching a given set of criteria. 4550 ''' 4551 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
4554class Queries: 4555 ''' 4556 A Query is a record of a single client request to a resource, such as a SQL query. 4557 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4558 The Queries service is read-only. 4559 See `strongdm.models.Query`. 4560 ''' 4561 def __init__(self, channel, client): 4562 self.parent = client 4563 self.stub = QueriesStub(channel) 4564 4565 def list(self, filter, *args, timeout=None): 4566 ''' 4567 List gets a list of Queries matching a given set of criteria. 4568 ''' 4569 deadline = None if timeout is None else time.time() + timeout 4570 req = QueryListRequest() 4571 req.meta.CopyFrom(ListRequestMetadata()) 4572 if self.parent.page_limit > 0: 4573 req.meta.limit = self.parent.page_limit 4574 if self.parent.snapshot_datetime is not None: 4575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4576 4577 req.filter = plumbing.quote_filter_args(filter, *args) 4578 4579 def generator(svc, req): 4580 tries = 0 4581 while True: 4582 t = None if deadline is None else deadline - time.time() 4583 try: 4584 plumbing_response = svc.stub.List( 4585 req, 4586 metadata=svc.parent.get_metadata('Queries.List', req), 4587 timeout=t) 4588 except Exception as e: 4589 if self.parent.shouldRetry(tries, e, deadline): 4590 tries += 1 4591 time.sleep( 4592 self.parent.exponentialBackoff(tries, deadline)) 4593 continue 4594 raise plumbing.convert_error_to_porcelain(e) from e 4595 tries = 0 4596 for plumbing_item in plumbing_response.queries: 4597 yield plumbing.convert_query_to_porcelain(plumbing_item) 4598 if plumbing_response.meta.next_cursor == '': 4599 break 4600 req.meta.cursor = plumbing_response.meta.next_cursor 4601 4602 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)
4565 def list(self, filter, *args, timeout=None): 4566 ''' 4567 List gets a list of Queries matching a given set of criteria. 4568 ''' 4569 deadline = None if timeout is None else time.time() + timeout 4570 req = QueryListRequest() 4571 req.meta.CopyFrom(ListRequestMetadata()) 4572 if self.parent.page_limit > 0: 4573 req.meta.limit = self.parent.page_limit 4574 if self.parent.snapshot_datetime is not None: 4575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4576 4577 req.filter = plumbing.quote_filter_args(filter, *args) 4578 4579 def generator(svc, req): 4580 tries = 0 4581 while True: 4582 t = None if deadline is None else deadline - time.time() 4583 try: 4584 plumbing_response = svc.stub.List( 4585 req, 4586 metadata=svc.parent.get_metadata('Queries.List', req), 4587 timeout=t) 4588 except Exception as e: 4589 if self.parent.shouldRetry(tries, e, deadline): 4590 tries += 1 4591 time.sleep( 4592 self.parent.exponentialBackoff(tries, deadline)) 4593 continue 4594 raise plumbing.convert_error_to_porcelain(e) from e 4595 tries = 0 4596 for plumbing_item in plumbing_response.queries: 4597 yield plumbing.convert_query_to_porcelain(plumbing_item) 4598 if plumbing_response.meta.next_cursor == '': 4599 break 4600 req.meta.cursor = plumbing_response.meta.next_cursor 4601 4602 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
4605class RemoteIdentities: 4606 ''' 4607 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4608 See `strongdm.models.RemoteIdentity`. 4609 ''' 4610 def __init__(self, channel, client): 4611 self.parent = client 4612 self.stub = RemoteIdentitiesStub(channel) 4613 4614 def create(self, remote_identity, timeout=None): 4615 ''' 4616 Create registers a new RemoteIdentity. 4617 ''' 4618 deadline = None if timeout is None else time.time() + timeout 4619 req = RemoteIdentityCreateRequest() 4620 4621 if remote_identity is not None: 4622 req.remote_identity.CopyFrom( 4623 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4624 tries = 0 4625 plumbing_response = None 4626 while True: 4627 t = None if deadline is None else deadline - time.time() 4628 try: 4629 plumbing_response = self.stub.Create( 4630 req, 4631 metadata=self.parent.get_metadata( 4632 'RemoteIdentities.Create', req), 4633 timeout=t) 4634 except Exception as e: 4635 if self.parent.shouldRetry(tries, e, deadline): 4636 tries += 1 4637 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4638 continue 4639 raise plumbing.convert_error_to_porcelain(e) from e 4640 break 4641 4642 resp = models.RemoteIdentityCreateResponse() 4643 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4644 plumbing_response.meta) 4645 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4646 plumbing_response.rate_limit) 4647 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4648 plumbing_response.remote_identity) 4649 return resp 4650 4651 def get(self, id, timeout=None): 4652 ''' 4653 Get reads one RemoteIdentity by ID. 4654 ''' 4655 deadline = None if timeout is None else time.time() + timeout 4656 req = RemoteIdentityGetRequest() 4657 if self.parent.snapshot_datetime is not None: 4658 req.meta.CopyFrom(GetRequestMetadata()) 4659 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4660 4661 req.id = (id) 4662 tries = 0 4663 plumbing_response = None 4664 while True: 4665 t = None if deadline is None else deadline - time.time() 4666 try: 4667 plumbing_response = self.stub.Get( 4668 req, 4669 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4670 req), 4671 timeout=t) 4672 except Exception as e: 4673 if self.parent.shouldRetry(tries, e, deadline): 4674 tries += 1 4675 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4676 continue 4677 raise plumbing.convert_error_to_porcelain(e) from e 4678 break 4679 4680 resp = models.RemoteIdentityGetResponse() 4681 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4682 plumbing_response.meta) 4683 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4684 plumbing_response.rate_limit) 4685 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4686 plumbing_response.remote_identity) 4687 return resp 4688 4689 def update(self, remote_identity, timeout=None): 4690 ''' 4691 Update replaces all the fields of a RemoteIdentity by ID. 4692 ''' 4693 deadline = None if timeout is None else time.time() + timeout 4694 req = RemoteIdentityUpdateRequest() 4695 4696 if remote_identity is not None: 4697 req.remote_identity.CopyFrom( 4698 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4699 tries = 0 4700 plumbing_response = None 4701 while True: 4702 t = None if deadline is None else deadline - time.time() 4703 try: 4704 plumbing_response = self.stub.Update( 4705 req, 4706 metadata=self.parent.get_metadata( 4707 'RemoteIdentities.Update', req), 4708 timeout=t) 4709 except Exception as e: 4710 if self.parent.shouldRetry(tries, e, deadline): 4711 tries += 1 4712 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4713 continue 4714 raise plumbing.convert_error_to_porcelain(e) from e 4715 break 4716 4717 resp = models.RemoteIdentityUpdateResponse() 4718 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4719 plumbing_response.meta) 4720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4721 plumbing_response.rate_limit) 4722 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4723 plumbing_response.remote_identity) 4724 return resp 4725 4726 def delete(self, id, timeout=None): 4727 ''' 4728 Delete removes a RemoteIdentity by ID. 4729 ''' 4730 deadline = None if timeout is None else time.time() + timeout 4731 req = RemoteIdentityDeleteRequest() 4732 4733 req.id = (id) 4734 tries = 0 4735 plumbing_response = None 4736 while True: 4737 t = None if deadline is None else deadline - time.time() 4738 try: 4739 plumbing_response = self.stub.Delete( 4740 req, 4741 metadata=self.parent.get_metadata( 4742 'RemoteIdentities.Delete', req), 4743 timeout=t) 4744 except Exception as e: 4745 if self.parent.shouldRetry(tries, e, deadline): 4746 tries += 1 4747 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4748 continue 4749 raise plumbing.convert_error_to_porcelain(e) from e 4750 break 4751 4752 resp = models.RemoteIdentityDeleteResponse() 4753 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4754 plumbing_response.meta) 4755 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4756 plumbing_response.rate_limit) 4757 return resp 4758 4759 def list(self, filter, *args, timeout=None): 4760 ''' 4761 List gets a list of RemoteIdentities matching a given set of criteria. 4762 ''' 4763 deadline = None if timeout is None else time.time() + timeout 4764 req = RemoteIdentityListRequest() 4765 req.meta.CopyFrom(ListRequestMetadata()) 4766 if self.parent.page_limit > 0: 4767 req.meta.limit = self.parent.page_limit 4768 if self.parent.snapshot_datetime is not None: 4769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4770 4771 req.filter = plumbing.quote_filter_args(filter, *args) 4772 4773 def generator(svc, req): 4774 tries = 0 4775 while True: 4776 t = None if deadline is None else deadline - time.time() 4777 try: 4778 plumbing_response = svc.stub.List( 4779 req, 4780 metadata=svc.parent.get_metadata( 4781 'RemoteIdentities.List', req), 4782 timeout=t) 4783 except Exception as e: 4784 if self.parent.shouldRetry(tries, e, deadline): 4785 tries += 1 4786 time.sleep( 4787 self.parent.exponentialBackoff(tries, deadline)) 4788 continue 4789 raise plumbing.convert_error_to_porcelain(e) from e 4790 tries = 0 4791 for plumbing_item in plumbing_response.remote_identities: 4792 yield plumbing.convert_remote_identity_to_porcelain( 4793 plumbing_item) 4794 if plumbing_response.meta.next_cursor == '': 4795 break 4796 req.meta.cursor = plumbing_response.meta.next_cursor 4797 4798 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)
4614 def create(self, remote_identity, timeout=None): 4615 ''' 4616 Create registers a new RemoteIdentity. 4617 ''' 4618 deadline = None if timeout is None else time.time() + timeout 4619 req = RemoteIdentityCreateRequest() 4620 4621 if remote_identity is not None: 4622 req.remote_identity.CopyFrom( 4623 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4624 tries = 0 4625 plumbing_response = None 4626 while True: 4627 t = None if deadline is None else deadline - time.time() 4628 try: 4629 plumbing_response = self.stub.Create( 4630 req, 4631 metadata=self.parent.get_metadata( 4632 'RemoteIdentities.Create', req), 4633 timeout=t) 4634 except Exception as e: 4635 if self.parent.shouldRetry(tries, e, deadline): 4636 tries += 1 4637 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4638 continue 4639 raise plumbing.convert_error_to_porcelain(e) from e 4640 break 4641 4642 resp = models.RemoteIdentityCreateResponse() 4643 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4644 plumbing_response.meta) 4645 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4646 plumbing_response.rate_limit) 4647 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4648 plumbing_response.remote_identity) 4649 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
4651 def get(self, id, timeout=None): 4652 ''' 4653 Get reads one RemoteIdentity by ID. 4654 ''' 4655 deadline = None if timeout is None else time.time() + timeout 4656 req = RemoteIdentityGetRequest() 4657 if self.parent.snapshot_datetime is not None: 4658 req.meta.CopyFrom(GetRequestMetadata()) 4659 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4660 4661 req.id = (id) 4662 tries = 0 4663 plumbing_response = None 4664 while True: 4665 t = None if deadline is None else deadline - time.time() 4666 try: 4667 plumbing_response = self.stub.Get( 4668 req, 4669 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4670 req), 4671 timeout=t) 4672 except Exception as e: 4673 if self.parent.shouldRetry(tries, e, deadline): 4674 tries += 1 4675 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4676 continue 4677 raise plumbing.convert_error_to_porcelain(e) from e 4678 break 4679 4680 resp = models.RemoteIdentityGetResponse() 4681 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4682 plumbing_response.meta) 4683 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4684 plumbing_response.rate_limit) 4685 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4686 plumbing_response.remote_identity) 4687 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
4689 def update(self, remote_identity, timeout=None): 4690 ''' 4691 Update replaces all the fields of a RemoteIdentity by ID. 4692 ''' 4693 deadline = None if timeout is None else time.time() + timeout 4694 req = RemoteIdentityUpdateRequest() 4695 4696 if remote_identity is not None: 4697 req.remote_identity.CopyFrom( 4698 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4699 tries = 0 4700 plumbing_response = None 4701 while True: 4702 t = None if deadline is None else deadline - time.time() 4703 try: 4704 plumbing_response = self.stub.Update( 4705 req, 4706 metadata=self.parent.get_metadata( 4707 'RemoteIdentities.Update', req), 4708 timeout=t) 4709 except Exception as e: 4710 if self.parent.shouldRetry(tries, e, deadline): 4711 tries += 1 4712 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4713 continue 4714 raise plumbing.convert_error_to_porcelain(e) from e 4715 break 4716 4717 resp = models.RemoteIdentityUpdateResponse() 4718 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4719 plumbing_response.meta) 4720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4721 plumbing_response.rate_limit) 4722 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4723 plumbing_response.remote_identity) 4724 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
4726 def delete(self, id, timeout=None): 4727 ''' 4728 Delete removes a RemoteIdentity by ID. 4729 ''' 4730 deadline = None if timeout is None else time.time() + timeout 4731 req = RemoteIdentityDeleteRequest() 4732 4733 req.id = (id) 4734 tries = 0 4735 plumbing_response = None 4736 while True: 4737 t = None if deadline is None else deadline - time.time() 4738 try: 4739 plumbing_response = self.stub.Delete( 4740 req, 4741 metadata=self.parent.get_metadata( 4742 'RemoteIdentities.Delete', req), 4743 timeout=t) 4744 except Exception as e: 4745 if self.parent.shouldRetry(tries, e, deadline): 4746 tries += 1 4747 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4748 continue 4749 raise plumbing.convert_error_to_porcelain(e) from e 4750 break 4751 4752 resp = models.RemoteIdentityDeleteResponse() 4753 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4754 plumbing_response.meta) 4755 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4756 plumbing_response.rate_limit) 4757 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
4759 def list(self, filter, *args, timeout=None): 4760 ''' 4761 List gets a list of RemoteIdentities matching a given set of criteria. 4762 ''' 4763 deadline = None if timeout is None else time.time() + timeout 4764 req = RemoteIdentityListRequest() 4765 req.meta.CopyFrom(ListRequestMetadata()) 4766 if self.parent.page_limit > 0: 4767 req.meta.limit = self.parent.page_limit 4768 if self.parent.snapshot_datetime is not None: 4769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4770 4771 req.filter = plumbing.quote_filter_args(filter, *args) 4772 4773 def generator(svc, req): 4774 tries = 0 4775 while True: 4776 t = None if deadline is None else deadline - time.time() 4777 try: 4778 plumbing_response = svc.stub.List( 4779 req, 4780 metadata=svc.parent.get_metadata( 4781 'RemoteIdentities.List', req), 4782 timeout=t) 4783 except Exception as e: 4784 if self.parent.shouldRetry(tries, e, deadline): 4785 tries += 1 4786 time.sleep( 4787 self.parent.exponentialBackoff(tries, deadline)) 4788 continue 4789 raise plumbing.convert_error_to_porcelain(e) from e 4790 tries = 0 4791 for plumbing_item in plumbing_response.remote_identities: 4792 yield plumbing.convert_remote_identity_to_porcelain( 4793 plumbing_item) 4794 if plumbing_response.meta.next_cursor == '': 4795 break 4796 req.meta.cursor = plumbing_response.meta.next_cursor 4797 4798 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
4801class SnapshotRemoteIdentities: 4802 ''' 4803 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 4804 service for historical queries. 4805 ''' 4806 def __init__(self, remote_identities): 4807 self.remote_identities = remote_identities 4808 4809 def get(self, id, timeout=None): 4810 ''' 4811 Get reads one RemoteIdentity by ID. 4812 ''' 4813 return self.remote_identities.get(id, timeout=timeout) 4814 4815 def list(self, filter, *args, timeout=None): 4816 ''' 4817 List gets a list of RemoteIdentities matching a given set of criteria. 4818 ''' 4819 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)
4809 def get(self, id, timeout=None): 4810 ''' 4811 Get reads one RemoteIdentity by ID. 4812 ''' 4813 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
4815 def list(self, filter, *args, timeout=None): 4816 ''' 4817 List gets a list of RemoteIdentities matching a given set of criteria. 4818 ''' 4819 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
4822class RemoteIdentitiesHistory: 4823 ''' 4824 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 4825 See `strongdm.models.RemoteIdentityHistory`. 4826 ''' 4827 def __init__(self, channel, client): 4828 self.parent = client 4829 self.stub = RemoteIdentitiesHistoryStub(channel) 4830 4831 def list(self, filter, *args, timeout=None): 4832 ''' 4833 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4834 ''' 4835 deadline = None if timeout is None else time.time() + timeout 4836 req = RemoteIdentityHistoryListRequest() 4837 req.meta.CopyFrom(ListRequestMetadata()) 4838 if self.parent.page_limit > 0: 4839 req.meta.limit = self.parent.page_limit 4840 if self.parent.snapshot_datetime is not None: 4841 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4842 4843 req.filter = plumbing.quote_filter_args(filter, *args) 4844 4845 def generator(svc, req): 4846 tries = 0 4847 while True: 4848 t = None if deadline is None else deadline - time.time() 4849 try: 4850 plumbing_response = svc.stub.List( 4851 req, 4852 metadata=svc.parent.get_metadata( 4853 'RemoteIdentitiesHistory.List', req), 4854 timeout=t) 4855 except Exception as e: 4856 if self.parent.shouldRetry(tries, e, deadline): 4857 tries += 1 4858 time.sleep( 4859 self.parent.exponentialBackoff(tries, deadline)) 4860 continue 4861 raise plumbing.convert_error_to_porcelain(e) from e 4862 tries = 0 4863 for plumbing_item in plumbing_response.history: 4864 yield plumbing.convert_remote_identity_history_to_porcelain( 4865 plumbing_item) 4866 if plumbing_response.meta.next_cursor == '': 4867 break 4868 req.meta.cursor = plumbing_response.meta.next_cursor 4869 4870 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)
4831 def list(self, filter, *args, timeout=None): 4832 ''' 4833 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4834 ''' 4835 deadline = None if timeout is None else time.time() + timeout 4836 req = RemoteIdentityHistoryListRequest() 4837 req.meta.CopyFrom(ListRequestMetadata()) 4838 if self.parent.page_limit > 0: 4839 req.meta.limit = self.parent.page_limit 4840 if self.parent.snapshot_datetime is not None: 4841 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4842 4843 req.filter = plumbing.quote_filter_args(filter, *args) 4844 4845 def generator(svc, req): 4846 tries = 0 4847 while True: 4848 t = None if deadline is None else deadline - time.time() 4849 try: 4850 plumbing_response = svc.stub.List( 4851 req, 4852 metadata=svc.parent.get_metadata( 4853 'RemoteIdentitiesHistory.List', req), 4854 timeout=t) 4855 except Exception as e: 4856 if self.parent.shouldRetry(tries, e, deadline): 4857 tries += 1 4858 time.sleep( 4859 self.parent.exponentialBackoff(tries, deadline)) 4860 continue 4861 raise plumbing.convert_error_to_porcelain(e) from e 4862 tries = 0 4863 for plumbing_item in plumbing_response.history: 4864 yield plumbing.convert_remote_identity_history_to_porcelain( 4865 plumbing_item) 4866 if plumbing_response.meta.next_cursor == '': 4867 break 4868 req.meta.cursor = plumbing_response.meta.next_cursor 4869 4870 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
4873class RemoteIdentityGroups: 4874 ''' 4875 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 4876 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 4877 See `strongdm.models.RemoteIdentityGroup`. 4878 ''' 4879 def __init__(self, channel, client): 4880 self.parent = client 4881 self.stub = RemoteIdentityGroupsStub(channel) 4882 4883 def get(self, id, timeout=None): 4884 ''' 4885 Get reads one RemoteIdentityGroup by ID. 4886 ''' 4887 deadline = None if timeout is None else time.time() + timeout 4888 req = RemoteIdentityGroupGetRequest() 4889 if self.parent.snapshot_datetime is not None: 4890 req.meta.CopyFrom(GetRequestMetadata()) 4891 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4892 4893 req.id = (id) 4894 tries = 0 4895 plumbing_response = None 4896 while True: 4897 t = None if deadline is None else deadline - time.time() 4898 try: 4899 plumbing_response = self.stub.Get( 4900 req, 4901 metadata=self.parent.get_metadata( 4902 'RemoteIdentityGroups.Get', req), 4903 timeout=t) 4904 except Exception as e: 4905 if self.parent.shouldRetry(tries, e, deadline): 4906 tries += 1 4907 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4908 continue 4909 raise plumbing.convert_error_to_porcelain(e) from e 4910 break 4911 4912 resp = models.RemoteIdentityGroupGetResponse() 4913 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4914 plumbing_response.meta) 4915 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4916 plumbing_response.rate_limit) 4917 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4918 plumbing_response.remote_identity_group) 4919 return resp 4920 4921 def list(self, filter, *args, timeout=None): 4922 ''' 4923 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4924 ''' 4925 deadline = None if timeout is None else time.time() + timeout 4926 req = RemoteIdentityGroupListRequest() 4927 req.meta.CopyFrom(ListRequestMetadata()) 4928 if self.parent.page_limit > 0: 4929 req.meta.limit = self.parent.page_limit 4930 if self.parent.snapshot_datetime is not None: 4931 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4932 4933 req.filter = plumbing.quote_filter_args(filter, *args) 4934 4935 def generator(svc, req): 4936 tries = 0 4937 while True: 4938 t = None if deadline is None else deadline - time.time() 4939 try: 4940 plumbing_response = svc.stub.List( 4941 req, 4942 metadata=svc.parent.get_metadata( 4943 'RemoteIdentityGroups.List', req), 4944 timeout=t) 4945 except Exception as e: 4946 if self.parent.shouldRetry(tries, e, deadline): 4947 tries += 1 4948 time.sleep( 4949 self.parent.exponentialBackoff(tries, deadline)) 4950 continue 4951 raise plumbing.convert_error_to_porcelain(e) from e 4952 tries = 0 4953 for plumbing_item in plumbing_response.remote_identity_groups: 4954 yield plumbing.convert_remote_identity_group_to_porcelain( 4955 plumbing_item) 4956 if plumbing_response.meta.next_cursor == '': 4957 break 4958 req.meta.cursor = plumbing_response.meta.next_cursor 4959 4960 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)
4883 def get(self, id, timeout=None): 4884 ''' 4885 Get reads one RemoteIdentityGroup by ID. 4886 ''' 4887 deadline = None if timeout is None else time.time() + timeout 4888 req = RemoteIdentityGroupGetRequest() 4889 if self.parent.snapshot_datetime is not None: 4890 req.meta.CopyFrom(GetRequestMetadata()) 4891 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4892 4893 req.id = (id) 4894 tries = 0 4895 plumbing_response = None 4896 while True: 4897 t = None if deadline is None else deadline - time.time() 4898 try: 4899 plumbing_response = self.stub.Get( 4900 req, 4901 metadata=self.parent.get_metadata( 4902 'RemoteIdentityGroups.Get', req), 4903 timeout=t) 4904 except Exception as e: 4905 if self.parent.shouldRetry(tries, e, deadline): 4906 tries += 1 4907 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4908 continue 4909 raise plumbing.convert_error_to_porcelain(e) from e 4910 break 4911 4912 resp = models.RemoteIdentityGroupGetResponse() 4913 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4914 plumbing_response.meta) 4915 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4916 plumbing_response.rate_limit) 4917 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4918 plumbing_response.remote_identity_group) 4919 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
4921 def list(self, filter, *args, timeout=None): 4922 ''' 4923 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4924 ''' 4925 deadline = None if timeout is None else time.time() + timeout 4926 req = RemoteIdentityGroupListRequest() 4927 req.meta.CopyFrom(ListRequestMetadata()) 4928 if self.parent.page_limit > 0: 4929 req.meta.limit = self.parent.page_limit 4930 if self.parent.snapshot_datetime is not None: 4931 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4932 4933 req.filter = plumbing.quote_filter_args(filter, *args) 4934 4935 def generator(svc, req): 4936 tries = 0 4937 while True: 4938 t = None if deadline is None else deadline - time.time() 4939 try: 4940 plumbing_response = svc.stub.List( 4941 req, 4942 metadata=svc.parent.get_metadata( 4943 'RemoteIdentityGroups.List', req), 4944 timeout=t) 4945 except Exception as e: 4946 if self.parent.shouldRetry(tries, e, deadline): 4947 tries += 1 4948 time.sleep( 4949 self.parent.exponentialBackoff(tries, deadline)) 4950 continue 4951 raise plumbing.convert_error_to_porcelain(e) from e 4952 tries = 0 4953 for plumbing_item in plumbing_response.remote_identity_groups: 4954 yield plumbing.convert_remote_identity_group_to_porcelain( 4955 plumbing_item) 4956 if plumbing_response.meta.next_cursor == '': 4957 break 4958 req.meta.cursor = plumbing_response.meta.next_cursor 4959 4960 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
4963class SnapshotRemoteIdentityGroups: 4964 ''' 4965 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 4966 service for historical queries. 4967 ''' 4968 def __init__(self, remote_identity_groups): 4969 self.remote_identity_groups = remote_identity_groups 4970 4971 def get(self, id, timeout=None): 4972 ''' 4973 Get reads one RemoteIdentityGroup by ID. 4974 ''' 4975 return self.remote_identity_groups.get(id, timeout=timeout) 4976 4977 def list(self, filter, *args, timeout=None): 4978 ''' 4979 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4980 ''' 4981 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)
4971 def get(self, id, timeout=None): 4972 ''' 4973 Get reads one RemoteIdentityGroup by ID. 4974 ''' 4975 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
4977 def list(self, filter, *args, timeout=None): 4978 ''' 4979 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4980 ''' 4981 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
4984class RemoteIdentityGroupsHistory: 4985 ''' 4986 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 4987 See `strongdm.models.RemoteIdentityGroupHistory`. 4988 ''' 4989 def __init__(self, channel, client): 4990 self.parent = client 4991 self.stub = RemoteIdentityGroupsHistoryStub(channel) 4992 4993 def list(self, filter, *args, timeout=None): 4994 ''' 4995 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4996 ''' 4997 deadline = None if timeout is None else time.time() + timeout 4998 req = RemoteIdentityGroupHistoryListRequest() 4999 req.meta.CopyFrom(ListRequestMetadata()) 5000 if self.parent.page_limit > 0: 5001 req.meta.limit = self.parent.page_limit 5002 if self.parent.snapshot_datetime is not None: 5003 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5004 5005 req.filter = plumbing.quote_filter_args(filter, *args) 5006 5007 def generator(svc, req): 5008 tries = 0 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = svc.stub.List( 5013 req, 5014 metadata=svc.parent.get_metadata( 5015 'RemoteIdentityGroupsHistory.List', req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep( 5021 self.parent.exponentialBackoff(tries, deadline)) 5022 continue 5023 raise plumbing.convert_error_to_porcelain(e) from e 5024 tries = 0 5025 for plumbing_item in plumbing_response.history: 5026 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5027 plumbing_item) 5028 if plumbing_response.meta.next_cursor == '': 5029 break 5030 req.meta.cursor = plumbing_response.meta.next_cursor 5031 5032 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)
4993 def list(self, filter, *args, timeout=None): 4994 ''' 4995 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4996 ''' 4997 deadline = None if timeout is None else time.time() + timeout 4998 req = RemoteIdentityGroupHistoryListRequest() 4999 req.meta.CopyFrom(ListRequestMetadata()) 5000 if self.parent.page_limit > 0: 5001 req.meta.limit = self.parent.page_limit 5002 if self.parent.snapshot_datetime is not None: 5003 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5004 5005 req.filter = plumbing.quote_filter_args(filter, *args) 5006 5007 def generator(svc, req): 5008 tries = 0 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = svc.stub.List( 5013 req, 5014 metadata=svc.parent.get_metadata( 5015 'RemoteIdentityGroupsHistory.List', req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep( 5021 self.parent.exponentialBackoff(tries, deadline)) 5022 continue 5023 raise plumbing.convert_error_to_porcelain(e) from e 5024 tries = 0 5025 for plumbing_item in plumbing_response.history: 5026 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5027 plumbing_item) 5028 if plumbing_response.meta.next_cursor == '': 5029 break 5030 req.meta.cursor = plumbing_response.meta.next_cursor 5031 5032 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
5035class Replays: 5036 ''' 5037 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5038 (otherwise referred to as a query). The Replays service is read-only. 5039 See `strongdm.models.ReplayChunk`. 5040 ''' 5041 def __init__(self, channel, client): 5042 self.parent = client 5043 self.stub = ReplaysStub(channel) 5044 5045 def list(self, filter, *args, timeout=None): 5046 ''' 5047 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5048 ''' 5049 deadline = None if timeout is None else time.time() + timeout 5050 req = ReplayListRequest() 5051 req.meta.CopyFrom(ListRequestMetadata()) 5052 if self.parent.page_limit > 0: 5053 req.meta.limit = self.parent.page_limit 5054 if self.parent.snapshot_datetime is not None: 5055 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5056 5057 req.filter = plumbing.quote_filter_args(filter, *args) 5058 5059 def generator(svc, req): 5060 tries = 0 5061 while True: 5062 t = None if deadline is None else deadline - time.time() 5063 try: 5064 plumbing_response = svc.stub.List( 5065 req, 5066 metadata=svc.parent.get_metadata('Replays.List', req), 5067 timeout=t) 5068 except Exception as e: 5069 if self.parent.shouldRetry(tries, e, deadline): 5070 tries += 1 5071 time.sleep( 5072 self.parent.exponentialBackoff(tries, deadline)) 5073 continue 5074 raise plumbing.convert_error_to_porcelain(e) from e 5075 tries = 0 5076 for plumbing_item in plumbing_response.chunks: 5077 yield plumbing.convert_replay_chunk_to_porcelain( 5078 plumbing_item) 5079 if plumbing_response.meta.next_cursor == '': 5080 break 5081 req.meta.cursor = plumbing_response.meta.next_cursor 5082 5083 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)
5045 def list(self, filter, *args, timeout=None): 5046 ''' 5047 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5048 ''' 5049 deadline = None if timeout is None else time.time() + timeout 5050 req = ReplayListRequest() 5051 req.meta.CopyFrom(ListRequestMetadata()) 5052 if self.parent.page_limit > 0: 5053 req.meta.limit = self.parent.page_limit 5054 if self.parent.snapshot_datetime is not None: 5055 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5056 5057 req.filter = plumbing.quote_filter_args(filter, *args) 5058 5059 def generator(svc, req): 5060 tries = 0 5061 while True: 5062 t = None if deadline is None else deadline - time.time() 5063 try: 5064 plumbing_response = svc.stub.List( 5065 req, 5066 metadata=svc.parent.get_metadata('Replays.List', req), 5067 timeout=t) 5068 except Exception as e: 5069 if self.parent.shouldRetry(tries, e, deadline): 5070 tries += 1 5071 time.sleep( 5072 self.parent.exponentialBackoff(tries, deadline)) 5073 continue 5074 raise plumbing.convert_error_to_porcelain(e) from e 5075 tries = 0 5076 for plumbing_item in plumbing_response.chunks: 5077 yield plumbing.convert_replay_chunk_to_porcelain( 5078 plumbing_item) 5079 if plumbing_response.meta.next_cursor == '': 5080 break 5081 req.meta.cursor = plumbing_response.meta.next_cursor 5082 5083 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
5086class Resources: 5087 ''' 5088 Resources are databases, servers, clusters, websites, or clouds that strongDM 5089 delegates access to. 5090 See: 5091 `strongdm.models.Aerospike` 5092 `strongdm.models.AKS` 5093 `strongdm.models.AKSBasicAuth` 5094 `strongdm.models.AKSServiceAccount` 5095 `strongdm.models.AKSServiceAccountUserImpersonation` 5096 `strongdm.models.AKSUserImpersonation` 5097 `strongdm.models.AmazonEKS` 5098 `strongdm.models.AmazonEKSInstanceProfile` 5099 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5100 `strongdm.models.AmazonEKSUserImpersonation` 5101 `strongdm.models.AmazonES` 5102 `strongdm.models.AmazonESIAM` 5103 `strongdm.models.AmazonMQAMQP091` 5104 `strongdm.models.Athena` 5105 `strongdm.models.AthenaIAM` 5106 `strongdm.models.AuroraMysql` 5107 `strongdm.models.AuroraMysqlIAM` 5108 `strongdm.models.AuroraPostgres` 5109 `strongdm.models.AuroraPostgresIAM` 5110 `strongdm.models.AWS` 5111 `strongdm.models.AWSConsole` 5112 `strongdm.models.AWSConsoleStaticKeyPair` 5113 `strongdm.models.AWSInstanceProfile` 5114 `strongdm.models.Azure` 5115 `strongdm.models.AzureCertificate` 5116 `strongdm.models.AzureMysql` 5117 `strongdm.models.AzurePostgres` 5118 `strongdm.models.AzurePostgresManagedIdentity` 5119 `strongdm.models.BigQuery` 5120 `strongdm.models.Cassandra` 5121 `strongdm.models.Citus` 5122 `strongdm.models.ClickHouseHTTP` 5123 `strongdm.models.ClickHouseMySQL` 5124 `strongdm.models.ClickHouseTCP` 5125 `strongdm.models.Clustrix` 5126 `strongdm.models.Cockroach` 5127 `strongdm.models.CouchbaseDatabase` 5128 `strongdm.models.CouchbaseWebUI` 5129 `strongdm.models.DB2I` 5130 `strongdm.models.DB2LUW` 5131 `strongdm.models.DocumentDBHost` 5132 `strongdm.models.DocumentDBHostIAM` 5133 `strongdm.models.DocumentDBReplicaSet` 5134 `strongdm.models.DocumentDBReplicaSetIAM` 5135 `strongdm.models.Druid` 5136 `strongdm.models.DynamoDB` 5137 `strongdm.models.DynamoDBIAM` 5138 `strongdm.models.Elastic` 5139 `strongdm.models.ElasticacheRedis` 5140 `strongdm.models.GCP` 5141 `strongdm.models.GCPConsole` 5142 `strongdm.models.GCPWIF` 5143 `strongdm.models.GoogleGKE` 5144 `strongdm.models.GoogleGKEUserImpersonation` 5145 `strongdm.models.Greenplum` 5146 `strongdm.models.HTTPAuth` 5147 `strongdm.models.HTTPBasicAuth` 5148 `strongdm.models.HTTPNoAuth` 5149 `strongdm.models.Kubernetes` 5150 `strongdm.models.KubernetesBasicAuth` 5151 `strongdm.models.KubernetesPodIdentity` 5152 `strongdm.models.KubernetesServiceAccount` 5153 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5154 `strongdm.models.KubernetesUserImpersonation` 5155 `strongdm.models.Maria` 5156 `strongdm.models.Memcached` 5157 `strongdm.models.Memsql` 5158 `strongdm.models.MongoHost` 5159 `strongdm.models.MongoLegacyHost` 5160 `strongdm.models.MongoLegacyReplicaset` 5161 `strongdm.models.MongoReplicaSet` 5162 `strongdm.models.MongoShardedCluster` 5163 `strongdm.models.MTLSMysql` 5164 `strongdm.models.MTLSPostgres` 5165 `strongdm.models.Mysql` 5166 `strongdm.models.Neptune` 5167 `strongdm.models.NeptuneIAM` 5168 `strongdm.models.Oracle` 5169 `strongdm.models.OracleNNE` 5170 `strongdm.models.Postgres` 5171 `strongdm.models.Presto` 5172 `strongdm.models.RabbitMQAMQP091` 5173 `strongdm.models.RawTCP` 5174 `strongdm.models.RDP` 5175 `strongdm.models.RDPCert` 5176 `strongdm.models.RDSPostgresIAM` 5177 `strongdm.models.Redis` 5178 `strongdm.models.RedisCluster` 5179 `strongdm.models.Redshift` 5180 `strongdm.models.RedshiftIAM` 5181 `strongdm.models.RedshiftServerlessIAM` 5182 `strongdm.models.SingleStore` 5183 `strongdm.models.Snowflake` 5184 `strongdm.models.Snowsight` 5185 `strongdm.models.SQLServer` 5186 `strongdm.models.SQLServerAzureAD` 5187 `strongdm.models.SQLServerKerberosAD` 5188 `strongdm.models.SSH` 5189 `strongdm.models.SSHCert` 5190 `strongdm.models.SSHCustomerKey` 5191 `strongdm.models.SSHPassword` 5192 `strongdm.models.Sybase` 5193 `strongdm.models.SybaseIQ` 5194 `strongdm.models.Teradata` 5195 `strongdm.models.Trino` 5196 `strongdm.models.Vertica` 5197 ''' 5198 def __init__(self, channel, client): 5199 self.parent = client 5200 self.stub = ResourcesStub(channel) 5201 5202 def enumerate_tags(self, filter, *args, timeout=None): 5203 ''' 5204 EnumerateTags gets a list of the filter matching tags. 5205 ''' 5206 deadline = None if timeout is None else time.time() + timeout 5207 req = EnumerateTagsRequest() 5208 req.meta.CopyFrom(ListRequestMetadata()) 5209 if self.parent.page_limit > 0: 5210 req.meta.limit = self.parent.page_limit 5211 if self.parent.snapshot_datetime is not None: 5212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5213 5214 req.filter = plumbing.quote_filter_args(filter, *args) 5215 5216 def generator(svc, req): 5217 tries = 0 5218 while True: 5219 t = None if deadline is None else deadline - time.time() 5220 try: 5221 plumbing_response = svc.stub.EnumerateTags( 5222 req, 5223 metadata=svc.parent.get_metadata( 5224 'Resources.EnumerateTags', req), 5225 timeout=t) 5226 except Exception as e: 5227 if self.parent.shouldRetry(tries, e, deadline): 5228 tries += 1 5229 time.sleep( 5230 self.parent.exponentialBackoff(tries, deadline)) 5231 continue 5232 raise plumbing.convert_error_to_porcelain(e) from e 5233 tries = 0 5234 for plumbing_item in plumbing_response.matches: 5235 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5236 if plumbing_response.meta.next_cursor == '': 5237 break 5238 req.meta.cursor = plumbing_response.meta.next_cursor 5239 5240 return generator(self, req) 5241 5242 def create(self, resource, timeout=None): 5243 ''' 5244 Create registers a new Resource. 5245 ''' 5246 deadline = None if timeout is None else time.time() + timeout 5247 req = ResourceCreateRequest() 5248 5249 if resource is not None: 5250 req.resource.CopyFrom( 5251 plumbing.convert_resource_to_plumbing(resource)) 5252 tries = 0 5253 plumbing_response = None 5254 while True: 5255 t = None if deadline is None else deadline - time.time() 5256 try: 5257 plumbing_response = self.stub.Create( 5258 req, 5259 metadata=self.parent.get_metadata('Resources.Create', req), 5260 timeout=t) 5261 except Exception as e: 5262 if self.parent.shouldRetry(tries, e, deadline): 5263 tries += 1 5264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5265 continue 5266 raise plumbing.convert_error_to_porcelain(e) from e 5267 break 5268 5269 resp = models.ResourceCreateResponse() 5270 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5271 plumbing_response.meta) 5272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5273 plumbing_response.rate_limit) 5274 resp.resource = plumbing.convert_resource_to_porcelain( 5275 plumbing_response.resource) 5276 return resp 5277 5278 def get(self, id, timeout=None): 5279 ''' 5280 Get reads one Resource by ID. 5281 ''' 5282 deadline = None if timeout is None else time.time() + timeout 5283 req = ResourceGetRequest() 5284 if self.parent.snapshot_datetime is not None: 5285 req.meta.CopyFrom(GetRequestMetadata()) 5286 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5287 5288 req.id = (id) 5289 tries = 0 5290 plumbing_response = None 5291 while True: 5292 t = None if deadline is None else deadline - time.time() 5293 try: 5294 plumbing_response = self.stub.Get( 5295 req, 5296 metadata=self.parent.get_metadata('Resources.Get', req), 5297 timeout=t) 5298 except Exception as e: 5299 if self.parent.shouldRetry(tries, e, deadline): 5300 tries += 1 5301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5302 continue 5303 raise plumbing.convert_error_to_porcelain(e) from e 5304 break 5305 5306 resp = models.ResourceGetResponse() 5307 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5308 plumbing_response.meta) 5309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5310 plumbing_response.rate_limit) 5311 resp.resource = plumbing.convert_resource_to_porcelain( 5312 plumbing_response.resource) 5313 return resp 5314 5315 def update(self, resource, timeout=None): 5316 ''' 5317 Update replaces all the fields of a Resource by ID. 5318 ''' 5319 deadline = None if timeout is None else time.time() + timeout 5320 req = ResourceUpdateRequest() 5321 5322 if resource is not None: 5323 req.resource.CopyFrom( 5324 plumbing.convert_resource_to_plumbing(resource)) 5325 tries = 0 5326 plumbing_response = None 5327 while True: 5328 t = None if deadline is None else deadline - time.time() 5329 try: 5330 plumbing_response = self.stub.Update( 5331 req, 5332 metadata=self.parent.get_metadata('Resources.Update', req), 5333 timeout=t) 5334 except Exception as e: 5335 if self.parent.shouldRetry(tries, e, deadline): 5336 tries += 1 5337 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5338 continue 5339 raise plumbing.convert_error_to_porcelain(e) from e 5340 break 5341 5342 resp = models.ResourceUpdateResponse() 5343 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5344 plumbing_response.meta) 5345 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5346 plumbing_response.rate_limit) 5347 resp.resource = plumbing.convert_resource_to_porcelain( 5348 plumbing_response.resource) 5349 return resp 5350 5351 def delete(self, id, timeout=None): 5352 ''' 5353 Delete removes a Resource by ID. 5354 ''' 5355 deadline = None if timeout is None else time.time() + timeout 5356 req = ResourceDeleteRequest() 5357 5358 req.id = (id) 5359 tries = 0 5360 plumbing_response = None 5361 while True: 5362 t = None if deadline is None else deadline - time.time() 5363 try: 5364 plumbing_response = self.stub.Delete( 5365 req, 5366 metadata=self.parent.get_metadata('Resources.Delete', req), 5367 timeout=t) 5368 except Exception as e: 5369 if self.parent.shouldRetry(tries, e, deadline): 5370 tries += 1 5371 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5372 continue 5373 raise plumbing.convert_error_to_porcelain(e) from e 5374 break 5375 5376 resp = models.ResourceDeleteResponse() 5377 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5378 plumbing_response.meta) 5379 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5380 plumbing_response.rate_limit) 5381 return resp 5382 5383 def list(self, filter, *args, timeout=None): 5384 ''' 5385 List gets a list of Resources matching a given set of criteria. 5386 ''' 5387 deadline = None if timeout is None else time.time() + timeout 5388 req = ResourceListRequest() 5389 req.meta.CopyFrom(ListRequestMetadata()) 5390 if self.parent.page_limit > 0: 5391 req.meta.limit = self.parent.page_limit 5392 if self.parent.snapshot_datetime is not None: 5393 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5394 5395 req.filter = plumbing.quote_filter_args(filter, *args) 5396 5397 def generator(svc, req): 5398 tries = 0 5399 while True: 5400 t = None if deadline is None else deadline - time.time() 5401 try: 5402 plumbing_response = svc.stub.List( 5403 req, 5404 metadata=svc.parent.get_metadata( 5405 'Resources.List', req), 5406 timeout=t) 5407 except Exception as e: 5408 if self.parent.shouldRetry(tries, e, deadline): 5409 tries += 1 5410 time.sleep( 5411 self.parent.exponentialBackoff(tries, deadline)) 5412 continue 5413 raise plumbing.convert_error_to_porcelain(e) from e 5414 tries = 0 5415 for plumbing_item in plumbing_response.resources: 5416 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5417 if plumbing_response.meta.next_cursor == '': 5418 break 5419 req.meta.cursor = plumbing_response.meta.next_cursor 5420 5421 return generator(self, req) 5422 5423 def healthcheck(self, id, timeout=None): 5424 ''' 5425 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5426 large network of Nodes. The call will return immediately, and the updated health of the 5427 Resource can be retrieved via Get or List. 5428 ''' 5429 deadline = None if timeout is None else time.time() + timeout 5430 req = ResourceHealthcheckRequest() 5431 5432 req.id = (id) 5433 tries = 0 5434 plumbing_response = None 5435 while True: 5436 t = None if deadline is None else deadline - time.time() 5437 try: 5438 plumbing_response = self.stub.Healthcheck( 5439 req, 5440 metadata=self.parent.get_metadata('Resources.Healthcheck', 5441 req), 5442 timeout=t) 5443 except Exception as e: 5444 if self.parent.shouldRetry(tries, e, deadline): 5445 tries += 1 5446 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5447 continue 5448 raise plumbing.convert_error_to_porcelain(e) from e 5449 break 5450 5451 resp = models.ResourceHealthcheckResponse() 5452 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5453 plumbing_response.meta) 5454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5455 plumbing_response.rate_limit) 5456 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.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.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.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.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)
5242 def create(self, resource, timeout=None): 5243 ''' 5244 Create registers a new Resource. 5245 ''' 5246 deadline = None if timeout is None else time.time() + timeout 5247 req = ResourceCreateRequest() 5248 5249 if resource is not None: 5250 req.resource.CopyFrom( 5251 plumbing.convert_resource_to_plumbing(resource)) 5252 tries = 0 5253 plumbing_response = None 5254 while True: 5255 t = None if deadline is None else deadline - time.time() 5256 try: 5257 plumbing_response = self.stub.Create( 5258 req, 5259 metadata=self.parent.get_metadata('Resources.Create', req), 5260 timeout=t) 5261 except Exception as e: 5262 if self.parent.shouldRetry(tries, e, deadline): 5263 tries += 1 5264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5265 continue 5266 raise plumbing.convert_error_to_porcelain(e) from e 5267 break 5268 5269 resp = models.ResourceCreateResponse() 5270 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5271 plumbing_response.meta) 5272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5273 plumbing_response.rate_limit) 5274 resp.resource = plumbing.convert_resource_to_porcelain( 5275 plumbing_response.resource) 5276 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
5278 def get(self, id, timeout=None): 5279 ''' 5280 Get reads one Resource by ID. 5281 ''' 5282 deadline = None if timeout is None else time.time() + timeout 5283 req = ResourceGetRequest() 5284 if self.parent.snapshot_datetime is not None: 5285 req.meta.CopyFrom(GetRequestMetadata()) 5286 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5287 5288 req.id = (id) 5289 tries = 0 5290 plumbing_response = None 5291 while True: 5292 t = None if deadline is None else deadline - time.time() 5293 try: 5294 plumbing_response = self.stub.Get( 5295 req, 5296 metadata=self.parent.get_metadata('Resources.Get', req), 5297 timeout=t) 5298 except Exception as e: 5299 if self.parent.shouldRetry(tries, e, deadline): 5300 tries += 1 5301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5302 continue 5303 raise plumbing.convert_error_to_porcelain(e) from e 5304 break 5305 5306 resp = models.ResourceGetResponse() 5307 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5308 plumbing_response.meta) 5309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5310 plumbing_response.rate_limit) 5311 resp.resource = plumbing.convert_resource_to_porcelain( 5312 plumbing_response.resource) 5313 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
5315 def update(self, resource, timeout=None): 5316 ''' 5317 Update replaces all the fields of a Resource by ID. 5318 ''' 5319 deadline = None if timeout is None else time.time() + timeout 5320 req = ResourceUpdateRequest() 5321 5322 if resource is not None: 5323 req.resource.CopyFrom( 5324 plumbing.convert_resource_to_plumbing(resource)) 5325 tries = 0 5326 plumbing_response = None 5327 while True: 5328 t = None if deadline is None else deadline - time.time() 5329 try: 5330 plumbing_response = self.stub.Update( 5331 req, 5332 metadata=self.parent.get_metadata('Resources.Update', req), 5333 timeout=t) 5334 except Exception as e: 5335 if self.parent.shouldRetry(tries, e, deadline): 5336 tries += 1 5337 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5338 continue 5339 raise plumbing.convert_error_to_porcelain(e) from e 5340 break 5341 5342 resp = models.ResourceUpdateResponse() 5343 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5344 plumbing_response.meta) 5345 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5346 plumbing_response.rate_limit) 5347 resp.resource = plumbing.convert_resource_to_porcelain( 5348 plumbing_response.resource) 5349 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
5351 def delete(self, id, timeout=None): 5352 ''' 5353 Delete removes a Resource by ID. 5354 ''' 5355 deadline = None if timeout is None else time.time() + timeout 5356 req = ResourceDeleteRequest() 5357 5358 req.id = (id) 5359 tries = 0 5360 plumbing_response = None 5361 while True: 5362 t = None if deadline is None else deadline - time.time() 5363 try: 5364 plumbing_response = self.stub.Delete( 5365 req, 5366 metadata=self.parent.get_metadata('Resources.Delete', req), 5367 timeout=t) 5368 except Exception as e: 5369 if self.parent.shouldRetry(tries, e, deadline): 5370 tries += 1 5371 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5372 continue 5373 raise plumbing.convert_error_to_porcelain(e) from e 5374 break 5375 5376 resp = models.ResourceDeleteResponse() 5377 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5378 plumbing_response.meta) 5379 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5380 plumbing_response.rate_limit) 5381 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
5383 def list(self, filter, *args, timeout=None): 5384 ''' 5385 List gets a list of Resources matching a given set of criteria. 5386 ''' 5387 deadline = None if timeout is None else time.time() + timeout 5388 req = ResourceListRequest() 5389 req.meta.CopyFrom(ListRequestMetadata()) 5390 if self.parent.page_limit > 0: 5391 req.meta.limit = self.parent.page_limit 5392 if self.parent.snapshot_datetime is not None: 5393 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5394 5395 req.filter = plumbing.quote_filter_args(filter, *args) 5396 5397 def generator(svc, req): 5398 tries = 0 5399 while True: 5400 t = None if deadline is None else deadline - time.time() 5401 try: 5402 plumbing_response = svc.stub.List( 5403 req, 5404 metadata=svc.parent.get_metadata( 5405 'Resources.List', req), 5406 timeout=t) 5407 except Exception as e: 5408 if self.parent.shouldRetry(tries, e, deadline): 5409 tries += 1 5410 time.sleep( 5411 self.parent.exponentialBackoff(tries, deadline)) 5412 continue 5413 raise plumbing.convert_error_to_porcelain(e) from e 5414 tries = 0 5415 for plumbing_item in plumbing_response.resources: 5416 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5417 if plumbing_response.meta.next_cursor == '': 5418 break 5419 req.meta.cursor = plumbing_response.meta.next_cursor 5420 5421 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
5423 def healthcheck(self, id, timeout=None): 5424 ''' 5425 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5426 large network of Nodes. The call will return immediately, and the updated health of the 5427 Resource can be retrieved via Get or List. 5428 ''' 5429 deadline = None if timeout is None else time.time() + timeout 5430 req = ResourceHealthcheckRequest() 5431 5432 req.id = (id) 5433 tries = 0 5434 plumbing_response = None 5435 while True: 5436 t = None if deadline is None else deadline - time.time() 5437 try: 5438 plumbing_response = self.stub.Healthcheck( 5439 req, 5440 metadata=self.parent.get_metadata('Resources.Healthcheck', 5441 req), 5442 timeout=t) 5443 except Exception as e: 5444 if self.parent.shouldRetry(tries, e, deadline): 5445 tries += 1 5446 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5447 continue 5448 raise plumbing.convert_error_to_porcelain(e) from e 5449 break 5450 5451 resp = models.ResourceHealthcheckResponse() 5452 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5453 plumbing_response.meta) 5454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5455 plumbing_response.rate_limit) 5456 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:
5459class SnapshotResources: 5460 ''' 5461 SnapshotResources exposes the read only methods of the Resources 5462 service for historical queries. 5463 ''' 5464 def __init__(self, resources): 5465 self.resources = resources 5466 5467 def get(self, id, timeout=None): 5468 ''' 5469 Get reads one Resource by ID. 5470 ''' 5471 return self.resources.get(id, timeout=timeout) 5472 5473 def list(self, filter, *args, timeout=None): 5474 ''' 5475 List gets a list of Resources matching a given set of criteria. 5476 ''' 5477 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)
5467 def get(self, id, timeout=None): 5468 ''' 5469 Get reads one Resource by ID. 5470 ''' 5471 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
5473 def list(self, filter, *args, timeout=None): 5474 ''' 5475 List gets a list of Resources matching a given set of criteria. 5476 ''' 5477 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
5480class ResourcesHistory: 5481 ''' 5482 ResourcesHistory records all changes to the state of a Resource. 5483 See `strongdm.models.ResourceHistory`. 5484 ''' 5485 def __init__(self, channel, client): 5486 self.parent = client 5487 self.stub = ResourcesHistoryStub(channel) 5488 5489 def list(self, filter, *args, timeout=None): 5490 ''' 5491 List gets a list of ResourceHistory records matching a given set of criteria. 5492 ''' 5493 deadline = None if timeout is None else time.time() + timeout 5494 req = ResourceHistoryListRequest() 5495 req.meta.CopyFrom(ListRequestMetadata()) 5496 if self.parent.page_limit > 0: 5497 req.meta.limit = self.parent.page_limit 5498 if self.parent.snapshot_datetime is not None: 5499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5500 5501 req.filter = plumbing.quote_filter_args(filter, *args) 5502 5503 def generator(svc, req): 5504 tries = 0 5505 while True: 5506 t = None if deadline is None else deadline - time.time() 5507 try: 5508 plumbing_response = svc.stub.List( 5509 req, 5510 metadata=svc.parent.get_metadata( 5511 'ResourcesHistory.List', req), 5512 timeout=t) 5513 except Exception as e: 5514 if self.parent.shouldRetry(tries, e, deadline): 5515 tries += 1 5516 time.sleep( 5517 self.parent.exponentialBackoff(tries, deadline)) 5518 continue 5519 raise plumbing.convert_error_to_porcelain(e) from e 5520 tries = 0 5521 for plumbing_item in plumbing_response.history: 5522 yield plumbing.convert_resource_history_to_porcelain( 5523 plumbing_item) 5524 if plumbing_response.meta.next_cursor == '': 5525 break 5526 req.meta.cursor = plumbing_response.meta.next_cursor 5527 5528 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)
5489 def list(self, filter, *args, timeout=None): 5490 ''' 5491 List gets a list of ResourceHistory records matching a given set of criteria. 5492 ''' 5493 deadline = None if timeout is None else time.time() + timeout 5494 req = ResourceHistoryListRequest() 5495 req.meta.CopyFrom(ListRequestMetadata()) 5496 if self.parent.page_limit > 0: 5497 req.meta.limit = self.parent.page_limit 5498 if self.parent.snapshot_datetime is not None: 5499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5500 5501 req.filter = plumbing.quote_filter_args(filter, *args) 5502 5503 def generator(svc, req): 5504 tries = 0 5505 while True: 5506 t = None if deadline is None else deadline - time.time() 5507 try: 5508 plumbing_response = svc.stub.List( 5509 req, 5510 metadata=svc.parent.get_metadata( 5511 'ResourcesHistory.List', req), 5512 timeout=t) 5513 except Exception as e: 5514 if self.parent.shouldRetry(tries, e, deadline): 5515 tries += 1 5516 time.sleep( 5517 self.parent.exponentialBackoff(tries, deadline)) 5518 continue 5519 raise plumbing.convert_error_to_porcelain(e) from e 5520 tries = 0 5521 for plumbing_item in plumbing_response.history: 5522 yield plumbing.convert_resource_history_to_porcelain( 5523 plumbing_item) 5524 if plumbing_response.meta.next_cursor == '': 5525 break 5526 req.meta.cursor = plumbing_response.meta.next_cursor 5527 5528 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
5531class RoleResources: 5532 ''' 5533 RoleResources enumerates the resources to which roles have access. 5534 The RoleResources service is read-only. 5535 See `strongdm.models.RoleResource`. 5536 ''' 5537 def __init__(self, channel, client): 5538 self.parent = client 5539 self.stub = RoleResourcesStub(channel) 5540 5541 def list(self, filter, *args, timeout=None): 5542 ''' 5543 List gets a list of RoleResource records matching a given set of criteria. 5544 ''' 5545 deadline = None if timeout is None else time.time() + timeout 5546 req = RoleResourceListRequest() 5547 req.meta.CopyFrom(ListRequestMetadata()) 5548 if self.parent.page_limit > 0: 5549 req.meta.limit = self.parent.page_limit 5550 if self.parent.snapshot_datetime is not None: 5551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5552 5553 req.filter = plumbing.quote_filter_args(filter, *args) 5554 5555 def generator(svc, req): 5556 tries = 0 5557 while True: 5558 t = None if deadline is None else deadline - time.time() 5559 try: 5560 plumbing_response = svc.stub.List( 5561 req, 5562 metadata=svc.parent.get_metadata( 5563 'RoleResources.List', req), 5564 timeout=t) 5565 except Exception as e: 5566 if self.parent.shouldRetry(tries, e, deadline): 5567 tries += 1 5568 time.sleep( 5569 self.parent.exponentialBackoff(tries, deadline)) 5570 continue 5571 raise plumbing.convert_error_to_porcelain(e) from e 5572 tries = 0 5573 for plumbing_item in plumbing_response.role_resources: 5574 yield plumbing.convert_role_resource_to_porcelain( 5575 plumbing_item) 5576 if plumbing_response.meta.next_cursor == '': 5577 break 5578 req.meta.cursor = plumbing_response.meta.next_cursor 5579 5580 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)
5541 def list(self, filter, *args, timeout=None): 5542 ''' 5543 List gets a list of RoleResource records matching a given set of criteria. 5544 ''' 5545 deadline = None if timeout is None else time.time() + timeout 5546 req = RoleResourceListRequest() 5547 req.meta.CopyFrom(ListRequestMetadata()) 5548 if self.parent.page_limit > 0: 5549 req.meta.limit = self.parent.page_limit 5550 if self.parent.snapshot_datetime is not None: 5551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5552 5553 req.filter = plumbing.quote_filter_args(filter, *args) 5554 5555 def generator(svc, req): 5556 tries = 0 5557 while True: 5558 t = None if deadline is None else deadline - time.time() 5559 try: 5560 plumbing_response = svc.stub.List( 5561 req, 5562 metadata=svc.parent.get_metadata( 5563 'RoleResources.List', req), 5564 timeout=t) 5565 except Exception as e: 5566 if self.parent.shouldRetry(tries, e, deadline): 5567 tries += 1 5568 time.sleep( 5569 self.parent.exponentialBackoff(tries, deadline)) 5570 continue 5571 raise plumbing.convert_error_to_porcelain(e) from e 5572 tries = 0 5573 for plumbing_item in plumbing_response.role_resources: 5574 yield plumbing.convert_role_resource_to_porcelain( 5575 plumbing_item) 5576 if plumbing_response.meta.next_cursor == '': 5577 break 5578 req.meta.cursor = plumbing_response.meta.next_cursor 5579 5580 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
5583class SnapshotRoleResources: 5584 ''' 5585 SnapshotRoleResources exposes the read only methods of the RoleResources 5586 service for historical queries. 5587 ''' 5588 def __init__(self, role_resources): 5589 self.role_resources = role_resources 5590 5591 def list(self, filter, *args, timeout=None): 5592 ''' 5593 List gets a list of RoleResource records matching a given set of criteria. 5594 ''' 5595 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)
5591 def list(self, filter, *args, timeout=None): 5592 ''' 5593 List gets a list of RoleResource records matching a given set of criteria. 5594 ''' 5595 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
5598class RoleResourcesHistory: 5599 ''' 5600 RoleResourcesHistory records all changes to the state of a RoleResource. 5601 See `strongdm.models.RoleResourceHistory`. 5602 ''' 5603 def __init__(self, channel, client): 5604 self.parent = client 5605 self.stub = RoleResourcesHistoryStub(channel) 5606 5607 def list(self, filter, *args, timeout=None): 5608 ''' 5609 List gets a list of RoleResourceHistory records matching a given set of criteria. 5610 ''' 5611 deadline = None if timeout is None else time.time() + timeout 5612 req = RoleResourceHistoryListRequest() 5613 req.meta.CopyFrom(ListRequestMetadata()) 5614 if self.parent.page_limit > 0: 5615 req.meta.limit = self.parent.page_limit 5616 if self.parent.snapshot_datetime is not None: 5617 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5618 5619 req.filter = plumbing.quote_filter_args(filter, *args) 5620 5621 def generator(svc, req): 5622 tries = 0 5623 while True: 5624 t = None if deadline is None else deadline - time.time() 5625 try: 5626 plumbing_response = svc.stub.List( 5627 req, 5628 metadata=svc.parent.get_metadata( 5629 'RoleResourcesHistory.List', req), 5630 timeout=t) 5631 except Exception as e: 5632 if self.parent.shouldRetry(tries, e, deadline): 5633 tries += 1 5634 time.sleep( 5635 self.parent.exponentialBackoff(tries, deadline)) 5636 continue 5637 raise plumbing.convert_error_to_porcelain(e) from e 5638 tries = 0 5639 for plumbing_item in plumbing_response.history: 5640 yield plumbing.convert_role_resource_history_to_porcelain( 5641 plumbing_item) 5642 if plumbing_response.meta.next_cursor == '': 5643 break 5644 req.meta.cursor = plumbing_response.meta.next_cursor 5645 5646 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)
5607 def list(self, filter, *args, timeout=None): 5608 ''' 5609 List gets a list of RoleResourceHistory records matching a given set of criteria. 5610 ''' 5611 deadline = None if timeout is None else time.time() + timeout 5612 req = RoleResourceHistoryListRequest() 5613 req.meta.CopyFrom(ListRequestMetadata()) 5614 if self.parent.page_limit > 0: 5615 req.meta.limit = self.parent.page_limit 5616 if self.parent.snapshot_datetime is not None: 5617 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5618 5619 req.filter = plumbing.quote_filter_args(filter, *args) 5620 5621 def generator(svc, req): 5622 tries = 0 5623 while True: 5624 t = None if deadline is None else deadline - time.time() 5625 try: 5626 plumbing_response = svc.stub.List( 5627 req, 5628 metadata=svc.parent.get_metadata( 5629 'RoleResourcesHistory.List', req), 5630 timeout=t) 5631 except Exception as e: 5632 if self.parent.shouldRetry(tries, e, deadline): 5633 tries += 1 5634 time.sleep( 5635 self.parent.exponentialBackoff(tries, deadline)) 5636 continue 5637 raise plumbing.convert_error_to_porcelain(e) from e 5638 tries = 0 5639 for plumbing_item in plumbing_response.history: 5640 yield plumbing.convert_role_resource_history_to_porcelain( 5641 plumbing_item) 5642 if plumbing_response.meta.next_cursor == '': 5643 break 5644 req.meta.cursor = plumbing_response.meta.next_cursor 5645 5646 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
Roles:
5649class Roles: 5650 ''' 5651 A Role has a list of access rules which determine which Resources the members 5652 of the Role have access to. An Account can be a member of multiple Roles via 5653 AccountAttachments. 5654 See `strongdm.models.Role`. 5655 ''' 5656 def __init__(self, channel, client): 5657 self.parent = client 5658 self.stub = RolesStub(channel) 5659 5660 def create(self, role, timeout=None): 5661 ''' 5662 Create registers a new Role. 5663 ''' 5664 deadline = None if timeout is None else time.time() + timeout 5665 req = RoleCreateRequest() 5666 5667 if role is not None: 5668 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5669 tries = 0 5670 plumbing_response = None 5671 while True: 5672 t = None if deadline is None else deadline - time.time() 5673 try: 5674 plumbing_response = self.stub.Create( 5675 req, 5676 metadata=self.parent.get_metadata('Roles.Create', req), 5677 timeout=t) 5678 except Exception as e: 5679 if self.parent.shouldRetry(tries, e, deadline): 5680 tries += 1 5681 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5682 continue 5683 raise plumbing.convert_error_to_porcelain(e) from e 5684 break 5685 5686 resp = models.RoleCreateResponse() 5687 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5688 plumbing_response.meta) 5689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5690 plumbing_response.rate_limit) 5691 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5692 return resp 5693 5694 def get(self, id, timeout=None): 5695 ''' 5696 Get reads one Role by ID. 5697 ''' 5698 deadline = None if timeout is None else time.time() + timeout 5699 req = RoleGetRequest() 5700 if self.parent.snapshot_datetime is not None: 5701 req.meta.CopyFrom(GetRequestMetadata()) 5702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5703 5704 req.id = (id) 5705 tries = 0 5706 plumbing_response = None 5707 while True: 5708 t = None if deadline is None else deadline - time.time() 5709 try: 5710 plumbing_response = self.stub.Get( 5711 req, 5712 metadata=self.parent.get_metadata('Roles.Get', req), 5713 timeout=t) 5714 except Exception as e: 5715 if self.parent.shouldRetry(tries, e, deadline): 5716 tries += 1 5717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5718 continue 5719 raise plumbing.convert_error_to_porcelain(e) from e 5720 break 5721 5722 resp = models.RoleGetResponse() 5723 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5724 plumbing_response.meta) 5725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5726 plumbing_response.rate_limit) 5727 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5728 return resp 5729 5730 def update(self, role, timeout=None): 5731 ''' 5732 Update replaces all the fields of a Role by ID. 5733 ''' 5734 deadline = None if timeout is None else time.time() + timeout 5735 req = RoleUpdateRequest() 5736 5737 if role is not None: 5738 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5739 tries = 0 5740 plumbing_response = None 5741 while True: 5742 t = None if deadline is None else deadline - time.time() 5743 try: 5744 plumbing_response = self.stub.Update( 5745 req, 5746 metadata=self.parent.get_metadata('Roles.Update', req), 5747 timeout=t) 5748 except Exception as e: 5749 if self.parent.shouldRetry(tries, e, deadline): 5750 tries += 1 5751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5752 continue 5753 raise plumbing.convert_error_to_porcelain(e) from e 5754 break 5755 5756 resp = models.RoleUpdateResponse() 5757 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5758 plumbing_response.meta) 5759 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5760 plumbing_response.rate_limit) 5761 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5762 return resp 5763 5764 def delete(self, id, timeout=None): 5765 ''' 5766 Delete removes a Role by ID. 5767 ''' 5768 deadline = None if timeout is None else time.time() + timeout 5769 req = RoleDeleteRequest() 5770 5771 req.id = (id) 5772 tries = 0 5773 plumbing_response = None 5774 while True: 5775 t = None if deadline is None else deadline - time.time() 5776 try: 5777 plumbing_response = self.stub.Delete( 5778 req, 5779 metadata=self.parent.get_metadata('Roles.Delete', req), 5780 timeout=t) 5781 except Exception as e: 5782 if self.parent.shouldRetry(tries, e, deadline): 5783 tries += 1 5784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5785 continue 5786 raise plumbing.convert_error_to_porcelain(e) from e 5787 break 5788 5789 resp = models.RoleDeleteResponse() 5790 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5791 plumbing_response.meta) 5792 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5793 plumbing_response.rate_limit) 5794 return resp 5795 5796 def list(self, filter, *args, timeout=None): 5797 ''' 5798 List gets a list of Roles matching a given set of criteria. 5799 ''' 5800 deadline = None if timeout is None else time.time() + timeout 5801 req = RoleListRequest() 5802 req.meta.CopyFrom(ListRequestMetadata()) 5803 if self.parent.page_limit > 0: 5804 req.meta.limit = self.parent.page_limit 5805 if self.parent.snapshot_datetime is not None: 5806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5807 5808 req.filter = plumbing.quote_filter_args(filter, *args) 5809 5810 def generator(svc, req): 5811 tries = 0 5812 while True: 5813 t = None if deadline is None else deadline - time.time() 5814 try: 5815 plumbing_response = svc.stub.List( 5816 req, 5817 metadata=svc.parent.get_metadata('Roles.List', req), 5818 timeout=t) 5819 except Exception as e: 5820 if self.parent.shouldRetry(tries, e, deadline): 5821 tries += 1 5822 time.sleep( 5823 self.parent.exponentialBackoff(tries, deadline)) 5824 continue 5825 raise plumbing.convert_error_to_porcelain(e) from e 5826 tries = 0 5827 for plumbing_item in plumbing_response.roles: 5828 yield plumbing.convert_role_to_porcelain(plumbing_item) 5829 if plumbing_response.meta.next_cursor == '': 5830 break 5831 req.meta.cursor = plumbing_response.meta.next_cursor 5832 5833 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)
5660 def create(self, role, timeout=None): 5661 ''' 5662 Create registers a new Role. 5663 ''' 5664 deadline = None if timeout is None else time.time() + timeout 5665 req = RoleCreateRequest() 5666 5667 if role is not None: 5668 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5669 tries = 0 5670 plumbing_response = None 5671 while True: 5672 t = None if deadline is None else deadline - time.time() 5673 try: 5674 plumbing_response = self.stub.Create( 5675 req, 5676 metadata=self.parent.get_metadata('Roles.Create', req), 5677 timeout=t) 5678 except Exception as e: 5679 if self.parent.shouldRetry(tries, e, deadline): 5680 tries += 1 5681 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5682 continue 5683 raise plumbing.convert_error_to_porcelain(e) from e 5684 break 5685 5686 resp = models.RoleCreateResponse() 5687 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5688 plumbing_response.meta) 5689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5690 plumbing_response.rate_limit) 5691 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5692 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
5694 def get(self, id, timeout=None): 5695 ''' 5696 Get reads one Role by ID. 5697 ''' 5698 deadline = None if timeout is None else time.time() + timeout 5699 req = RoleGetRequest() 5700 if self.parent.snapshot_datetime is not None: 5701 req.meta.CopyFrom(GetRequestMetadata()) 5702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5703 5704 req.id = (id) 5705 tries = 0 5706 plumbing_response = None 5707 while True: 5708 t = None if deadline is None else deadline - time.time() 5709 try: 5710 plumbing_response = self.stub.Get( 5711 req, 5712 metadata=self.parent.get_metadata('Roles.Get', req), 5713 timeout=t) 5714 except Exception as e: 5715 if self.parent.shouldRetry(tries, e, deadline): 5716 tries += 1 5717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5718 continue 5719 raise plumbing.convert_error_to_porcelain(e) from e 5720 break 5721 5722 resp = models.RoleGetResponse() 5723 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5724 plumbing_response.meta) 5725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5726 plumbing_response.rate_limit) 5727 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5728 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
5730 def update(self, role, timeout=None): 5731 ''' 5732 Update replaces all the fields of a Role by ID. 5733 ''' 5734 deadline = None if timeout is None else time.time() + timeout 5735 req = RoleUpdateRequest() 5736 5737 if role is not None: 5738 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5739 tries = 0 5740 plumbing_response = None 5741 while True: 5742 t = None if deadline is None else deadline - time.time() 5743 try: 5744 plumbing_response = self.stub.Update( 5745 req, 5746 metadata=self.parent.get_metadata('Roles.Update', req), 5747 timeout=t) 5748 except Exception as e: 5749 if self.parent.shouldRetry(tries, e, deadline): 5750 tries += 1 5751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5752 continue 5753 raise plumbing.convert_error_to_porcelain(e) from e 5754 break 5755 5756 resp = models.RoleUpdateResponse() 5757 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5758 plumbing_response.meta) 5759 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5760 plumbing_response.rate_limit) 5761 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5762 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
5764 def delete(self, id, timeout=None): 5765 ''' 5766 Delete removes a Role by ID. 5767 ''' 5768 deadline = None if timeout is None else time.time() + timeout 5769 req = RoleDeleteRequest() 5770 5771 req.id = (id) 5772 tries = 0 5773 plumbing_response = None 5774 while True: 5775 t = None if deadline is None else deadline - time.time() 5776 try: 5777 plumbing_response = self.stub.Delete( 5778 req, 5779 metadata=self.parent.get_metadata('Roles.Delete', req), 5780 timeout=t) 5781 except Exception as e: 5782 if self.parent.shouldRetry(tries, e, deadline): 5783 tries += 1 5784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5785 continue 5786 raise plumbing.convert_error_to_porcelain(e) from e 5787 break 5788 5789 resp = models.RoleDeleteResponse() 5790 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5791 plumbing_response.meta) 5792 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5793 plumbing_response.rate_limit) 5794 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
5796 def list(self, filter, *args, timeout=None): 5797 ''' 5798 List gets a list of Roles matching a given set of criteria. 5799 ''' 5800 deadline = None if timeout is None else time.time() + timeout 5801 req = RoleListRequest() 5802 req.meta.CopyFrom(ListRequestMetadata()) 5803 if self.parent.page_limit > 0: 5804 req.meta.limit = self.parent.page_limit 5805 if self.parent.snapshot_datetime is not None: 5806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5807 5808 req.filter = plumbing.quote_filter_args(filter, *args) 5809 5810 def generator(svc, req): 5811 tries = 0 5812 while True: 5813 t = None if deadline is None else deadline - time.time() 5814 try: 5815 plumbing_response = svc.stub.List( 5816 req, 5817 metadata=svc.parent.get_metadata('Roles.List', req), 5818 timeout=t) 5819 except Exception as e: 5820 if self.parent.shouldRetry(tries, e, deadline): 5821 tries += 1 5822 time.sleep( 5823 self.parent.exponentialBackoff(tries, deadline)) 5824 continue 5825 raise plumbing.convert_error_to_porcelain(e) from e 5826 tries = 0 5827 for plumbing_item in plumbing_response.roles: 5828 yield plumbing.convert_role_to_porcelain(plumbing_item) 5829 if plumbing_response.meta.next_cursor == '': 5830 break 5831 req.meta.cursor = plumbing_response.meta.next_cursor 5832 5833 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
5836class SnapshotRoles: 5837 ''' 5838 SnapshotRoles exposes the read only methods of the Roles 5839 service for historical queries. 5840 ''' 5841 def __init__(self, roles): 5842 self.roles = roles 5843 5844 def get(self, id, timeout=None): 5845 ''' 5846 Get reads one Role by ID. 5847 ''' 5848 return self.roles.get(id, timeout=timeout) 5849 5850 def list(self, filter, *args, timeout=None): 5851 ''' 5852 List gets a list of Roles matching a given set of criteria. 5853 ''' 5854 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
RolesHistory:
5857class RolesHistory: 5858 ''' 5859 RolesHistory records all changes to the state of a Role. 5860 See `strongdm.models.RoleHistory`. 5861 ''' 5862 def __init__(self, channel, client): 5863 self.parent = client 5864 self.stub = RolesHistoryStub(channel) 5865 5866 def list(self, filter, *args, timeout=None): 5867 ''' 5868 List gets a list of RoleHistory records matching a given set of criteria. 5869 ''' 5870 deadline = None if timeout is None else time.time() + timeout 5871 req = RoleHistoryListRequest() 5872 req.meta.CopyFrom(ListRequestMetadata()) 5873 if self.parent.page_limit > 0: 5874 req.meta.limit = self.parent.page_limit 5875 if self.parent.snapshot_datetime is not None: 5876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5877 5878 req.filter = plumbing.quote_filter_args(filter, *args) 5879 5880 def generator(svc, req): 5881 tries = 0 5882 while True: 5883 t = None if deadline is None else deadline - time.time() 5884 try: 5885 plumbing_response = svc.stub.List( 5886 req, 5887 metadata=svc.parent.get_metadata( 5888 'RolesHistory.List', req), 5889 timeout=t) 5890 except Exception as e: 5891 if self.parent.shouldRetry(tries, e, deadline): 5892 tries += 1 5893 time.sleep( 5894 self.parent.exponentialBackoff(tries, deadline)) 5895 continue 5896 raise plumbing.convert_error_to_porcelain(e) from e 5897 tries = 0 5898 for plumbing_item in plumbing_response.history: 5899 yield plumbing.convert_role_history_to_porcelain( 5900 plumbing_item) 5901 if plumbing_response.meta.next_cursor == '': 5902 break 5903 req.meta.cursor = plumbing_response.meta.next_cursor 5904 5905 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)
5866 def list(self, filter, *args, timeout=None): 5867 ''' 5868 List gets a list of RoleHistory records matching a given set of criteria. 5869 ''' 5870 deadline = None if timeout is None else time.time() + timeout 5871 req = RoleHistoryListRequest() 5872 req.meta.CopyFrom(ListRequestMetadata()) 5873 if self.parent.page_limit > 0: 5874 req.meta.limit = self.parent.page_limit 5875 if self.parent.snapshot_datetime is not None: 5876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5877 5878 req.filter = plumbing.quote_filter_args(filter, *args) 5879 5880 def generator(svc, req): 5881 tries = 0 5882 while True: 5883 t = None if deadline is None else deadline - time.time() 5884 try: 5885 plumbing_response = svc.stub.List( 5886 req, 5887 metadata=svc.parent.get_metadata( 5888 'RolesHistory.List', req), 5889 timeout=t) 5890 except Exception as e: 5891 if self.parent.shouldRetry(tries, e, deadline): 5892 tries += 1 5893 time.sleep( 5894 self.parent.exponentialBackoff(tries, deadline)) 5895 continue 5896 raise plumbing.convert_error_to_porcelain(e) from e 5897 tries = 0 5898 for plumbing_item in plumbing_response.history: 5899 yield plumbing.convert_role_history_to_porcelain( 5900 plumbing_item) 5901 if plumbing_response.meta.next_cursor == '': 5902 break 5903 req.meta.cursor = plumbing_response.meta.next_cursor 5904 5905 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
5908class SecretStores: 5909 ''' 5910 SecretStores are servers where resource secrets (passwords, keys) are stored. 5911 See: 5912 `strongdm.models.ActiveDirectoryStore` 5913 `strongdm.models.AWSStore` 5914 `strongdm.models.AWSCertX509Store` 5915 `strongdm.models.AzureStore` 5916 `strongdm.models.CyberarkConjurStore` 5917 `strongdm.models.CyberarkPAMStore` 5918 `strongdm.models.CyberarkPAMExperimentalStore` 5919 `strongdm.models.DelineaStore` 5920 `strongdm.models.GCPStore` 5921 `strongdm.models.GCPCertX509Store` 5922 `strongdm.models.KeyfactorSSHStore` 5923 `strongdm.models.KeyfactorX509Store` 5924 `strongdm.models.VaultAppRoleStore` 5925 `strongdm.models.VaultAppRoleCertSSHStore` 5926 `strongdm.models.VaultAppRoleCertX509Store` 5927 `strongdm.models.VaultAWSEC2Store` 5928 `strongdm.models.VaultAWSIAMStore` 5929 `strongdm.models.VaultTLSStore` 5930 `strongdm.models.VaultTLSCertSSHStore` 5931 `strongdm.models.VaultTLSCertX509Store` 5932 `strongdm.models.VaultTokenStore` 5933 `strongdm.models.VaultTokenCertSSHStore` 5934 `strongdm.models.VaultTokenCertX509Store` 5935 ''' 5936 def __init__(self, channel, client): 5937 self.parent = client 5938 self.stub = SecretStoresStub(channel) 5939 5940 def create(self, secret_store, timeout=None): 5941 deadline = None if timeout is None else time.time() + timeout 5942 req = SecretStoreCreateRequest() 5943 5944 if secret_store is not None: 5945 req.secret_store.CopyFrom( 5946 plumbing.convert_secret_store_to_plumbing(secret_store)) 5947 tries = 0 5948 plumbing_response = None 5949 while True: 5950 t = None if deadline is None else deadline - time.time() 5951 try: 5952 plumbing_response = self.stub.Create( 5953 req, 5954 metadata=self.parent.get_metadata('SecretStores.Create', 5955 req), 5956 timeout=t) 5957 except Exception as e: 5958 if self.parent.shouldRetry(tries, e, deadline): 5959 tries += 1 5960 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5961 continue 5962 raise plumbing.convert_error_to_porcelain(e) from e 5963 break 5964 5965 resp = models.SecretStoreCreateResponse() 5966 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5967 plumbing_response.meta) 5968 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5969 plumbing_response.rate_limit) 5970 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5971 plumbing_response.secret_store) 5972 return resp 5973 5974 def get(self, id, timeout=None): 5975 ''' 5976 Get reads one SecretStore by ID. 5977 ''' 5978 deadline = None if timeout is None else time.time() + timeout 5979 req = SecretStoreGetRequest() 5980 if self.parent.snapshot_datetime is not None: 5981 req.meta.CopyFrom(GetRequestMetadata()) 5982 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5983 5984 req.id = (id) 5985 tries = 0 5986 plumbing_response = None 5987 while True: 5988 t = None if deadline is None else deadline - time.time() 5989 try: 5990 plumbing_response = self.stub.Get( 5991 req, 5992 metadata=self.parent.get_metadata('SecretStores.Get', req), 5993 timeout=t) 5994 except Exception as e: 5995 if self.parent.shouldRetry(tries, e, deadline): 5996 tries += 1 5997 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5998 continue 5999 raise plumbing.convert_error_to_porcelain(e) from e 6000 break 6001 6002 resp = models.SecretStoreGetResponse() 6003 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6004 plumbing_response.meta) 6005 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6006 plumbing_response.rate_limit) 6007 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6008 plumbing_response.secret_store) 6009 return resp 6010 6011 def update(self, secret_store, timeout=None): 6012 ''' 6013 Update replaces all the fields of a SecretStore by ID. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = SecretStoreUpdateRequest() 6017 6018 if secret_store is not None: 6019 req.secret_store.CopyFrom( 6020 plumbing.convert_secret_store_to_plumbing(secret_store)) 6021 tries = 0 6022 plumbing_response = None 6023 while True: 6024 t = None if deadline is None else deadline - time.time() 6025 try: 6026 plumbing_response = self.stub.Update( 6027 req, 6028 metadata=self.parent.get_metadata('SecretStores.Update', 6029 req), 6030 timeout=t) 6031 except Exception as e: 6032 if self.parent.shouldRetry(tries, e, deadline): 6033 tries += 1 6034 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6035 continue 6036 raise plumbing.convert_error_to_porcelain(e) from e 6037 break 6038 6039 resp = models.SecretStoreUpdateResponse() 6040 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6041 plumbing_response.meta) 6042 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6043 plumbing_response.rate_limit) 6044 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6045 plumbing_response.secret_store) 6046 return resp 6047 6048 def delete(self, id, timeout=None): 6049 ''' 6050 Delete removes a SecretStore by ID. 6051 ''' 6052 deadline = None if timeout is None else time.time() + timeout 6053 req = SecretStoreDeleteRequest() 6054 6055 req.id = (id) 6056 tries = 0 6057 plumbing_response = None 6058 while True: 6059 t = None if deadline is None else deadline - time.time() 6060 try: 6061 plumbing_response = self.stub.Delete( 6062 req, 6063 metadata=self.parent.get_metadata('SecretStores.Delete', 6064 req), 6065 timeout=t) 6066 except Exception as e: 6067 if self.parent.shouldRetry(tries, e, deadline): 6068 tries += 1 6069 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6070 continue 6071 raise plumbing.convert_error_to_porcelain(e) from e 6072 break 6073 6074 resp = models.SecretStoreDeleteResponse() 6075 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6076 plumbing_response.meta) 6077 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6078 plumbing_response.rate_limit) 6079 return resp 6080 6081 def list(self, filter, *args, timeout=None): 6082 ''' 6083 List gets a list of SecretStores matching a given set of criteria. 6084 ''' 6085 deadline = None if timeout is None else time.time() + timeout 6086 req = SecretStoreListRequest() 6087 req.meta.CopyFrom(ListRequestMetadata()) 6088 if self.parent.page_limit > 0: 6089 req.meta.limit = self.parent.page_limit 6090 if self.parent.snapshot_datetime is not None: 6091 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6092 6093 req.filter = plumbing.quote_filter_args(filter, *args) 6094 6095 def generator(svc, req): 6096 tries = 0 6097 while True: 6098 t = None if deadline is None else deadline - time.time() 6099 try: 6100 plumbing_response = svc.stub.List( 6101 req, 6102 metadata=svc.parent.get_metadata( 6103 'SecretStores.List', req), 6104 timeout=t) 6105 except Exception as e: 6106 if self.parent.shouldRetry(tries, e, deadline): 6107 tries += 1 6108 time.sleep( 6109 self.parent.exponentialBackoff(tries, deadline)) 6110 continue 6111 raise plumbing.convert_error_to_porcelain(e) from e 6112 tries = 0 6113 for plumbing_item in plumbing_response.secret_stores: 6114 yield plumbing.convert_secret_store_to_porcelain( 6115 plumbing_item) 6116 if plumbing_response.meta.next_cursor == '': 6117 break 6118 req.meta.cursor = plumbing_response.meta.next_cursor 6119 6120 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.VaultAppRoleStore
strongdm.models.VaultAppRoleCertSSHStore
strongdm.models.VaultAppRoleCertX509Store
strongdm.models.VaultAWSEC2Store
strongdm.models.VaultAWSIAMStore
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)
5940 def create(self, secret_store, timeout=None): 5941 deadline = None if timeout is None else time.time() + timeout 5942 req = SecretStoreCreateRequest() 5943 5944 if secret_store is not None: 5945 req.secret_store.CopyFrom( 5946 plumbing.convert_secret_store_to_plumbing(secret_store)) 5947 tries = 0 5948 plumbing_response = None 5949 while True: 5950 t = None if deadline is None else deadline - time.time() 5951 try: 5952 plumbing_response = self.stub.Create( 5953 req, 5954 metadata=self.parent.get_metadata('SecretStores.Create', 5955 req), 5956 timeout=t) 5957 except Exception as e: 5958 if self.parent.shouldRetry(tries, e, deadline): 5959 tries += 1 5960 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5961 continue 5962 raise plumbing.convert_error_to_porcelain(e) from e 5963 break 5964 5965 resp = models.SecretStoreCreateResponse() 5966 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5967 plumbing_response.meta) 5968 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5969 plumbing_response.rate_limit) 5970 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5971 plumbing_response.secret_store) 5972 return resp
def
get(self, id, timeout=None)
5974 def get(self, id, timeout=None): 5975 ''' 5976 Get reads one SecretStore by ID. 5977 ''' 5978 deadline = None if timeout is None else time.time() + timeout 5979 req = SecretStoreGetRequest() 5980 if self.parent.snapshot_datetime is not None: 5981 req.meta.CopyFrom(GetRequestMetadata()) 5982 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5983 5984 req.id = (id) 5985 tries = 0 5986 plumbing_response = None 5987 while True: 5988 t = None if deadline is None else deadline - time.time() 5989 try: 5990 plumbing_response = self.stub.Get( 5991 req, 5992 metadata=self.parent.get_metadata('SecretStores.Get', req), 5993 timeout=t) 5994 except Exception as e: 5995 if self.parent.shouldRetry(tries, e, deadline): 5996 tries += 1 5997 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5998 continue 5999 raise plumbing.convert_error_to_porcelain(e) from e 6000 break 6001 6002 resp = models.SecretStoreGetResponse() 6003 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6004 plumbing_response.meta) 6005 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6006 plumbing_response.rate_limit) 6007 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6008 plumbing_response.secret_store) 6009 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
6011 def update(self, secret_store, timeout=None): 6012 ''' 6013 Update replaces all the fields of a SecretStore by ID. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = SecretStoreUpdateRequest() 6017 6018 if secret_store is not None: 6019 req.secret_store.CopyFrom( 6020 plumbing.convert_secret_store_to_plumbing(secret_store)) 6021 tries = 0 6022 plumbing_response = None 6023 while True: 6024 t = None if deadline is None else deadline - time.time() 6025 try: 6026 plumbing_response = self.stub.Update( 6027 req, 6028 metadata=self.parent.get_metadata('SecretStores.Update', 6029 req), 6030 timeout=t) 6031 except Exception as e: 6032 if self.parent.shouldRetry(tries, e, deadline): 6033 tries += 1 6034 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6035 continue 6036 raise plumbing.convert_error_to_porcelain(e) from e 6037 break 6038 6039 resp = models.SecretStoreUpdateResponse() 6040 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6041 plumbing_response.meta) 6042 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6043 plumbing_response.rate_limit) 6044 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6045 plumbing_response.secret_store) 6046 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
6048 def delete(self, id, timeout=None): 6049 ''' 6050 Delete removes a SecretStore by ID. 6051 ''' 6052 deadline = None if timeout is None else time.time() + timeout 6053 req = SecretStoreDeleteRequest() 6054 6055 req.id = (id) 6056 tries = 0 6057 plumbing_response = None 6058 while True: 6059 t = None if deadline is None else deadline - time.time() 6060 try: 6061 plumbing_response = self.stub.Delete( 6062 req, 6063 metadata=self.parent.get_metadata('SecretStores.Delete', 6064 req), 6065 timeout=t) 6066 except Exception as e: 6067 if self.parent.shouldRetry(tries, e, deadline): 6068 tries += 1 6069 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6070 continue 6071 raise plumbing.convert_error_to_porcelain(e) from e 6072 break 6073 6074 resp = models.SecretStoreDeleteResponse() 6075 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6076 plumbing_response.meta) 6077 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6078 plumbing_response.rate_limit) 6079 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6081 def list(self, filter, *args, timeout=None): 6082 ''' 6083 List gets a list of SecretStores matching a given set of criteria. 6084 ''' 6085 deadline = None if timeout is None else time.time() + timeout 6086 req = SecretStoreListRequest() 6087 req.meta.CopyFrom(ListRequestMetadata()) 6088 if self.parent.page_limit > 0: 6089 req.meta.limit = self.parent.page_limit 6090 if self.parent.snapshot_datetime is not None: 6091 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6092 6093 req.filter = plumbing.quote_filter_args(filter, *args) 6094 6095 def generator(svc, req): 6096 tries = 0 6097 while True: 6098 t = None if deadline is None else deadline - time.time() 6099 try: 6100 plumbing_response = svc.stub.List( 6101 req, 6102 metadata=svc.parent.get_metadata( 6103 'SecretStores.List', req), 6104 timeout=t) 6105 except Exception as e: 6106 if self.parent.shouldRetry(tries, e, deadline): 6107 tries += 1 6108 time.sleep( 6109 self.parent.exponentialBackoff(tries, deadline)) 6110 continue 6111 raise plumbing.convert_error_to_porcelain(e) from e 6112 tries = 0 6113 for plumbing_item in plumbing_response.secret_stores: 6114 yield plumbing.convert_secret_store_to_porcelain( 6115 plumbing_item) 6116 if plumbing_response.meta.next_cursor == '': 6117 break 6118 req.meta.cursor = plumbing_response.meta.next_cursor 6119 6120 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
6123class SnapshotSecretStores: 6124 ''' 6125 SnapshotSecretStores exposes the read only methods of the SecretStores 6126 service for historical queries. 6127 ''' 6128 def __init__(self, secret_stores): 6129 self.secret_stores = secret_stores 6130 6131 def get(self, id, timeout=None): 6132 ''' 6133 Get reads one SecretStore by ID. 6134 ''' 6135 return self.secret_stores.get(id, timeout=timeout) 6136 6137 def list(self, filter, *args, timeout=None): 6138 ''' 6139 List gets a list of SecretStores matching a given set of criteria. 6140 ''' 6141 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)
6131 def get(self, id, timeout=None): 6132 ''' 6133 Get reads one SecretStore by ID. 6134 ''' 6135 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6137 def list(self, filter, *args, timeout=None): 6138 ''' 6139 List gets a list of SecretStores matching a given set of criteria. 6140 ''' 6141 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
6144class SecretEngines: 6145 ''' 6146 6147 See: 6148 `strongdm.models.ActiveDirectoryEngine` 6149 `strongdm.models.KeyValueEngine` 6150 ''' 6151 def __init__(self, channel, client): 6152 self.parent = client 6153 self.stub = SecretEnginesStub(channel) 6154 6155 def list(self, filter, *args, timeout=None): 6156 ''' 6157 List returns a list of Secret Engines 6158 ''' 6159 deadline = None if timeout is None else time.time() + timeout 6160 req = SecretEngineListRequest() 6161 req.meta.CopyFrom(ListRequestMetadata()) 6162 if self.parent.page_limit > 0: 6163 req.meta.limit = self.parent.page_limit 6164 if self.parent.snapshot_datetime is not None: 6165 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6166 6167 req.filter = plumbing.quote_filter_args(filter, *args) 6168 6169 def generator(svc, req): 6170 tries = 0 6171 while True: 6172 t = None if deadline is None else deadline - time.time() 6173 try: 6174 plumbing_response = svc.stub.List( 6175 req, 6176 metadata=svc.parent.get_metadata( 6177 'SecretEngines.List', req), 6178 timeout=t) 6179 except Exception as e: 6180 if self.parent.shouldRetry(tries, e, deadline): 6181 tries += 1 6182 time.sleep( 6183 self.parent.exponentialBackoff(tries, deadline)) 6184 continue 6185 raise plumbing.convert_error_to_porcelain(e) from e 6186 tries = 0 6187 for plumbing_item in plumbing_response.secret_engines: 6188 yield plumbing.convert_secret_engine_to_porcelain( 6189 plumbing_item) 6190 if plumbing_response.meta.next_cursor == '': 6191 break 6192 req.meta.cursor = plumbing_response.meta.next_cursor 6193 6194 return generator(self, req) 6195 6196 def get(self, id, timeout=None): 6197 ''' 6198 Get returns a secret engine details 6199 ''' 6200 deadline = None if timeout is None else time.time() + timeout 6201 req = SecretEngineGetRequest() 6202 if self.parent.snapshot_datetime is not None: 6203 req.meta.CopyFrom(GetRequestMetadata()) 6204 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6205 6206 req.id = (id) 6207 tries = 0 6208 plumbing_response = None 6209 while True: 6210 t = None if deadline is None else deadline - time.time() 6211 try: 6212 plumbing_response = self.stub.Get( 6213 req, 6214 metadata=self.parent.get_metadata('SecretEngines.Get', 6215 req), 6216 timeout=t) 6217 except Exception as e: 6218 if self.parent.shouldRetry(tries, e, deadline): 6219 tries += 1 6220 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6221 continue 6222 raise plumbing.convert_error_to_porcelain(e) from e 6223 break 6224 6225 resp = models.SecretEngineGetResponse() 6226 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6227 plumbing_response.meta) 6228 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6229 plumbing_response.rate_limit) 6230 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6231 plumbing_response.secret_engine) 6232 return resp 6233 6234 def create(self, secret_engine, timeout=None): 6235 ''' 6236 Create creates a secret engine 6237 ''' 6238 deadline = None if timeout is None else time.time() + timeout 6239 req = SecretEngineCreateRequest() 6240 6241 if secret_engine is not None: 6242 req.secret_engine.CopyFrom( 6243 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6244 tries = 0 6245 plumbing_response = None 6246 while True: 6247 t = None if deadline is None else deadline - time.time() 6248 try: 6249 plumbing_response = self.stub.Create( 6250 req, 6251 metadata=self.parent.get_metadata('SecretEngines.Create', 6252 req), 6253 timeout=t) 6254 except Exception as e: 6255 if self.parent.shouldRetry(tries, e, deadline): 6256 tries += 1 6257 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6258 continue 6259 raise plumbing.convert_error_to_porcelain(e) from e 6260 break 6261 6262 resp = models.SecretEngineCreateResponse() 6263 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6264 plumbing_response.meta) 6265 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6266 plumbing_response.rate_limit) 6267 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6268 plumbing_response.secret_engine) 6269 return resp 6270 6271 def update(self, secret_engine, timeout=None): 6272 ''' 6273 Update updates a secret engine 6274 ''' 6275 deadline = None if timeout is None else time.time() + timeout 6276 req = SecretEngineUpdateRequest() 6277 6278 if secret_engine is not None: 6279 req.secret_engine.CopyFrom( 6280 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6281 tries = 0 6282 plumbing_response = None 6283 while True: 6284 t = None if deadline is None else deadline - time.time() 6285 try: 6286 plumbing_response = self.stub.Update( 6287 req, 6288 metadata=self.parent.get_metadata('SecretEngines.Update', 6289 req), 6290 timeout=t) 6291 except Exception as e: 6292 if self.parent.shouldRetry(tries, e, deadline): 6293 tries += 1 6294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6295 continue 6296 raise plumbing.convert_error_to_porcelain(e) from e 6297 break 6298 6299 resp = models.SecretEngineUpdateResponse() 6300 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6301 plumbing_response.meta) 6302 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6303 plumbing_response.rate_limit) 6304 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6305 plumbing_response.secret_engine) 6306 return resp 6307 6308 def delete(self, id, timeout=None): 6309 ''' 6310 Delete deletes a secret engine 6311 ''' 6312 deadline = None if timeout is None else time.time() + timeout 6313 req = SecretEngineDeleteRequest() 6314 6315 req.id = (id) 6316 tries = 0 6317 plumbing_response = None 6318 while True: 6319 t = None if deadline is None else deadline - time.time() 6320 try: 6321 plumbing_response = self.stub.Delete( 6322 req, 6323 metadata=self.parent.get_metadata('SecretEngines.Delete', 6324 req), 6325 timeout=t) 6326 except Exception as e: 6327 if self.parent.shouldRetry(tries, e, deadline): 6328 tries += 1 6329 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6330 continue 6331 raise plumbing.convert_error_to_porcelain(e) from e 6332 break 6333 6334 resp = models.SecretEngineDeleteResponse() 6335 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6336 plumbing_response.rate_limit) 6337 return resp 6338 6339 def list_secret_stores(self, filter, *args, timeout=None): 6340 ''' 6341 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6342 for Secret Engine 6343 ''' 6344 deadline = None if timeout is None else time.time() + timeout 6345 req = SecretStoreListRequest() 6346 req.meta.CopyFrom(ListRequestMetadata()) 6347 if self.parent.page_limit > 0: 6348 req.meta.limit = self.parent.page_limit 6349 if self.parent.snapshot_datetime is not None: 6350 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6351 6352 req.filter = plumbing.quote_filter_args(filter, *args) 6353 6354 def generator(svc, req): 6355 tries = 0 6356 while True: 6357 t = None if deadline is None else deadline - time.time() 6358 try: 6359 plumbing_response = svc.stub.ListSecretStores( 6360 req, 6361 metadata=svc.parent.get_metadata( 6362 'SecretEngines.ListSecretStores', req), 6363 timeout=t) 6364 except Exception as e: 6365 if self.parent.shouldRetry(tries, e, deadline): 6366 tries += 1 6367 time.sleep( 6368 self.parent.exponentialBackoff(tries, deadline)) 6369 continue 6370 raise plumbing.convert_error_to_porcelain(e) from e 6371 tries = 0 6372 for plumbing_item in plumbing_response.secret_stores: 6373 yield plumbing.convert_secret_store_to_porcelain( 6374 plumbing_item) 6375 if plumbing_response.meta.next_cursor == '': 6376 break 6377 req.meta.cursor = plumbing_response.meta.next_cursor 6378 6379 return generator(self, req) 6380 6381 def generate_keys(self, secret_engine_id, timeout=None): 6382 ''' 6383 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6384 ''' 6385 deadline = None if timeout is None else time.time() + timeout 6386 req = GenerateKeysRequest() 6387 6388 req.secret_engine_id = (secret_engine_id) 6389 tries = 0 6390 plumbing_response = None 6391 while True: 6392 t = None if deadline is None else deadline - time.time() 6393 try: 6394 plumbing_response = self.stub.GenerateKeys( 6395 req, 6396 metadata=self.parent.get_metadata( 6397 'SecretEngines.GenerateKeys', req), 6398 timeout=t) 6399 except Exception as e: 6400 if self.parent.shouldRetry(tries, e, deadline): 6401 tries += 1 6402 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6403 continue 6404 raise plumbing.convert_error_to_porcelain(e) from e 6405 break 6406 6407 resp = models.GenerateKeysResponse() 6408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6409 plumbing_response.rate_limit) 6410 return resp 6411 6412 def healthcheck(self, secret_engine_id, timeout=None): 6413 ''' 6414 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6415 ''' 6416 deadline = None if timeout is None else time.time() + timeout 6417 req = HealthcheckRequest() 6418 6419 req.secret_engine_id = (secret_engine_id) 6420 tries = 0 6421 plumbing_response = None 6422 while True: 6423 t = None if deadline is None else deadline - time.time() 6424 try: 6425 plumbing_response = self.stub.Healthcheck( 6426 req, 6427 metadata=self.parent.get_metadata( 6428 'SecretEngines.Healthcheck', req), 6429 timeout=t) 6430 except Exception as e: 6431 if self.parent.shouldRetry(tries, e, deadline): 6432 tries += 1 6433 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6434 continue 6435 raise plumbing.convert_error_to_porcelain(e) from e 6436 break 6437 6438 resp = models.HealthcheckResponse() 6439 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6440 plumbing_response.rate_limit) 6441 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6442 plumbing_response.status) 6443 return resp 6444 6445 def rotate(self, id, password_policy, timeout=None): 6446 ''' 6447 Rotate rotates secret engine's credentials 6448 ''' 6449 deadline = None if timeout is None else time.time() + timeout 6450 req = SecretEngineRotateRequest() 6451 6452 req.id = (id) 6453 if password_policy is not None: 6454 req.password_policy.CopyFrom( 6455 plumbing.convert_secret_engine_password_policy_to_plumbing( 6456 password_policy)) 6457 tries = 0 6458 plumbing_response = None 6459 while True: 6460 t = None if deadline is None else deadline - time.time() 6461 try: 6462 plumbing_response = self.stub.Rotate( 6463 req, 6464 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6465 req), 6466 timeout=t) 6467 except Exception as e: 6468 if self.parent.shouldRetry(tries, e, deadline): 6469 tries += 1 6470 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6471 continue 6472 raise plumbing.convert_error_to_porcelain(e) from e 6473 break 6474 6475 resp = models.SecretEngineRotateResponse() 6476 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6477 plumbing_response.rate_limit) 6478 return resp
def
list(self, filter, *args, timeout=None)
6155 def list(self, filter, *args, timeout=None): 6156 ''' 6157 List returns a list of Secret Engines 6158 ''' 6159 deadline = None if timeout is None else time.time() + timeout 6160 req = SecretEngineListRequest() 6161 req.meta.CopyFrom(ListRequestMetadata()) 6162 if self.parent.page_limit > 0: 6163 req.meta.limit = self.parent.page_limit 6164 if self.parent.snapshot_datetime is not None: 6165 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6166 6167 req.filter = plumbing.quote_filter_args(filter, *args) 6168 6169 def generator(svc, req): 6170 tries = 0 6171 while True: 6172 t = None if deadline is None else deadline - time.time() 6173 try: 6174 plumbing_response = svc.stub.List( 6175 req, 6176 metadata=svc.parent.get_metadata( 6177 'SecretEngines.List', req), 6178 timeout=t) 6179 except Exception as e: 6180 if self.parent.shouldRetry(tries, e, deadline): 6181 tries += 1 6182 time.sleep( 6183 self.parent.exponentialBackoff(tries, deadline)) 6184 continue 6185 raise plumbing.convert_error_to_porcelain(e) from e 6186 tries = 0 6187 for plumbing_item in plumbing_response.secret_engines: 6188 yield plumbing.convert_secret_engine_to_porcelain( 6189 plumbing_item) 6190 if plumbing_response.meta.next_cursor == '': 6191 break 6192 req.meta.cursor = plumbing_response.meta.next_cursor 6193 6194 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
6196 def get(self, id, timeout=None): 6197 ''' 6198 Get returns a secret engine details 6199 ''' 6200 deadline = None if timeout is None else time.time() + timeout 6201 req = SecretEngineGetRequest() 6202 if self.parent.snapshot_datetime is not None: 6203 req.meta.CopyFrom(GetRequestMetadata()) 6204 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6205 6206 req.id = (id) 6207 tries = 0 6208 plumbing_response = None 6209 while True: 6210 t = None if deadline is None else deadline - time.time() 6211 try: 6212 plumbing_response = self.stub.Get( 6213 req, 6214 metadata=self.parent.get_metadata('SecretEngines.Get', 6215 req), 6216 timeout=t) 6217 except Exception as e: 6218 if self.parent.shouldRetry(tries, e, deadline): 6219 tries += 1 6220 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6221 continue 6222 raise plumbing.convert_error_to_porcelain(e) from e 6223 break 6224 6225 resp = models.SecretEngineGetResponse() 6226 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6227 plumbing_response.meta) 6228 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6229 plumbing_response.rate_limit) 6230 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6231 plumbing_response.secret_engine) 6232 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
6234 def create(self, secret_engine, timeout=None): 6235 ''' 6236 Create creates a secret engine 6237 ''' 6238 deadline = None if timeout is None else time.time() + timeout 6239 req = SecretEngineCreateRequest() 6240 6241 if secret_engine is not None: 6242 req.secret_engine.CopyFrom( 6243 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6244 tries = 0 6245 plumbing_response = None 6246 while True: 6247 t = None if deadline is None else deadline - time.time() 6248 try: 6249 plumbing_response = self.stub.Create( 6250 req, 6251 metadata=self.parent.get_metadata('SecretEngines.Create', 6252 req), 6253 timeout=t) 6254 except Exception as e: 6255 if self.parent.shouldRetry(tries, e, deadline): 6256 tries += 1 6257 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6258 continue 6259 raise plumbing.convert_error_to_porcelain(e) from e 6260 break 6261 6262 resp = models.SecretEngineCreateResponse() 6263 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6264 plumbing_response.meta) 6265 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6266 plumbing_response.rate_limit) 6267 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6268 plumbing_response.secret_engine) 6269 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
6271 def update(self, secret_engine, timeout=None): 6272 ''' 6273 Update updates a secret engine 6274 ''' 6275 deadline = None if timeout is None else time.time() + timeout 6276 req = SecretEngineUpdateRequest() 6277 6278 if secret_engine is not None: 6279 req.secret_engine.CopyFrom( 6280 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6281 tries = 0 6282 plumbing_response = None 6283 while True: 6284 t = None if deadline is None else deadline - time.time() 6285 try: 6286 plumbing_response = self.stub.Update( 6287 req, 6288 metadata=self.parent.get_metadata('SecretEngines.Update', 6289 req), 6290 timeout=t) 6291 except Exception as e: 6292 if self.parent.shouldRetry(tries, e, deadline): 6293 tries += 1 6294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6295 continue 6296 raise plumbing.convert_error_to_porcelain(e) from e 6297 break 6298 6299 resp = models.SecretEngineUpdateResponse() 6300 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6301 plumbing_response.meta) 6302 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6303 plumbing_response.rate_limit) 6304 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6305 plumbing_response.secret_engine) 6306 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
6308 def delete(self, id, timeout=None): 6309 ''' 6310 Delete deletes a secret engine 6311 ''' 6312 deadline = None if timeout is None else time.time() + timeout 6313 req = SecretEngineDeleteRequest() 6314 6315 req.id = (id) 6316 tries = 0 6317 plumbing_response = None 6318 while True: 6319 t = None if deadline is None else deadline - time.time() 6320 try: 6321 plumbing_response = self.stub.Delete( 6322 req, 6323 metadata=self.parent.get_metadata('SecretEngines.Delete', 6324 req), 6325 timeout=t) 6326 except Exception as e: 6327 if self.parent.shouldRetry(tries, e, deadline): 6328 tries += 1 6329 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6330 continue 6331 raise plumbing.convert_error_to_porcelain(e) from e 6332 break 6333 6334 resp = models.SecretEngineDeleteResponse() 6335 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6336 plumbing_response.rate_limit) 6337 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
6339 def list_secret_stores(self, filter, *args, timeout=None): 6340 ''' 6341 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6342 for Secret Engine 6343 ''' 6344 deadline = None if timeout is None else time.time() + timeout 6345 req = SecretStoreListRequest() 6346 req.meta.CopyFrom(ListRequestMetadata()) 6347 if self.parent.page_limit > 0: 6348 req.meta.limit = self.parent.page_limit 6349 if self.parent.snapshot_datetime is not None: 6350 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6351 6352 req.filter = plumbing.quote_filter_args(filter, *args) 6353 6354 def generator(svc, req): 6355 tries = 0 6356 while True: 6357 t = None if deadline is None else deadline - time.time() 6358 try: 6359 plumbing_response = svc.stub.ListSecretStores( 6360 req, 6361 metadata=svc.parent.get_metadata( 6362 'SecretEngines.ListSecretStores', req), 6363 timeout=t) 6364 except Exception as e: 6365 if self.parent.shouldRetry(tries, e, deadline): 6366 tries += 1 6367 time.sleep( 6368 self.parent.exponentialBackoff(tries, deadline)) 6369 continue 6370 raise plumbing.convert_error_to_porcelain(e) from e 6371 tries = 0 6372 for plumbing_item in plumbing_response.secret_stores: 6373 yield plumbing.convert_secret_store_to_porcelain( 6374 plumbing_item) 6375 if plumbing_response.meta.next_cursor == '': 6376 break 6377 req.meta.cursor = plumbing_response.meta.next_cursor 6378 6379 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)
6381 def generate_keys(self, secret_engine_id, timeout=None): 6382 ''' 6383 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6384 ''' 6385 deadline = None if timeout is None else time.time() + timeout 6386 req = GenerateKeysRequest() 6387 6388 req.secret_engine_id = (secret_engine_id) 6389 tries = 0 6390 plumbing_response = None 6391 while True: 6392 t = None if deadline is None else deadline - time.time() 6393 try: 6394 plumbing_response = self.stub.GenerateKeys( 6395 req, 6396 metadata=self.parent.get_metadata( 6397 'SecretEngines.GenerateKeys', req), 6398 timeout=t) 6399 except Exception as e: 6400 if self.parent.shouldRetry(tries, e, deadline): 6401 tries += 1 6402 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6403 continue 6404 raise plumbing.convert_error_to_porcelain(e) from e 6405 break 6406 6407 resp = models.GenerateKeysResponse() 6408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6409 plumbing_response.rate_limit) 6410 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)
6412 def healthcheck(self, secret_engine_id, timeout=None): 6413 ''' 6414 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6415 ''' 6416 deadline = None if timeout is None else time.time() + timeout 6417 req = HealthcheckRequest() 6418 6419 req.secret_engine_id = (secret_engine_id) 6420 tries = 0 6421 plumbing_response = None 6422 while True: 6423 t = None if deadline is None else deadline - time.time() 6424 try: 6425 plumbing_response = self.stub.Healthcheck( 6426 req, 6427 metadata=self.parent.get_metadata( 6428 'SecretEngines.Healthcheck', req), 6429 timeout=t) 6430 except Exception as e: 6431 if self.parent.shouldRetry(tries, e, deadline): 6432 tries += 1 6433 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6434 continue 6435 raise plumbing.convert_error_to_porcelain(e) from e 6436 break 6437 6438 resp = models.HealthcheckResponse() 6439 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6440 plumbing_response.rate_limit) 6441 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6442 plumbing_response.status) 6443 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
6445 def rotate(self, id, password_policy, timeout=None): 6446 ''' 6447 Rotate rotates secret engine's credentials 6448 ''' 6449 deadline = None if timeout is None else time.time() + timeout 6450 req = SecretEngineRotateRequest() 6451 6452 req.id = (id) 6453 if password_policy is not None: 6454 req.password_policy.CopyFrom( 6455 plumbing.convert_secret_engine_password_policy_to_plumbing( 6456 password_policy)) 6457 tries = 0 6458 plumbing_response = None 6459 while True: 6460 t = None if deadline is None else deadline - time.time() 6461 try: 6462 plumbing_response = self.stub.Rotate( 6463 req, 6464 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6465 req), 6466 timeout=t) 6467 except Exception as e: 6468 if self.parent.shouldRetry(tries, e, deadline): 6469 tries += 1 6470 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6471 continue 6472 raise plumbing.convert_error_to_porcelain(e) from e 6473 break 6474 6475 resp = models.SecretEngineRotateResponse() 6476 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6477 plumbing_response.rate_limit) 6478 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
6481class SecretStoreHealths: 6482 ''' 6483 SecretStoreHealths exposes health states for secret stores. 6484 See `strongdm.models.SecretStoreHealth`. 6485 ''' 6486 def __init__(self, channel, client): 6487 self.parent = client 6488 self.stub = SecretStoreHealthsStub(channel) 6489 6490 def list(self, filter, *args, timeout=None): 6491 ''' 6492 List reports the health status of node to secret store pairs. 6493 ''' 6494 deadline = None if timeout is None else time.time() + timeout 6495 req = SecretStoreHealthListRequest() 6496 req.meta.CopyFrom(ListRequestMetadata()) 6497 if self.parent.page_limit > 0: 6498 req.meta.limit = self.parent.page_limit 6499 if self.parent.snapshot_datetime is not None: 6500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6501 6502 req.filter = plumbing.quote_filter_args(filter, *args) 6503 6504 def generator(svc, req): 6505 tries = 0 6506 while True: 6507 t = None if deadline is None else deadline - time.time() 6508 try: 6509 plumbing_response = svc.stub.List( 6510 req, 6511 metadata=svc.parent.get_metadata( 6512 'SecretStoreHealths.List', req), 6513 timeout=t) 6514 except Exception as e: 6515 if self.parent.shouldRetry(tries, e, deadline): 6516 tries += 1 6517 time.sleep( 6518 self.parent.exponentialBackoff(tries, deadline)) 6519 continue 6520 raise plumbing.convert_error_to_porcelain(e) from e 6521 tries = 0 6522 for plumbing_item in plumbing_response.secret_store_healths: 6523 yield plumbing.convert_secret_store_health_to_porcelain( 6524 plumbing_item) 6525 if plumbing_response.meta.next_cursor == '': 6526 break 6527 req.meta.cursor = plumbing_response.meta.next_cursor 6528 6529 return generator(self, req) 6530 6531 def healthcheck(self, secret_store_id, timeout=None): 6532 ''' 6533 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6534 to propagate across a large network of Nodes. The call will return immediately, and the 6535 updated health of the Secret Store can be retrieved via List. 6536 ''' 6537 deadline = None if timeout is None else time.time() + timeout 6538 req = SecretStoreHealthcheckRequest() 6539 6540 req.secret_store_id = (secret_store_id) 6541 tries = 0 6542 plumbing_response = None 6543 while True: 6544 t = None if deadline is None else deadline - time.time() 6545 try: 6546 plumbing_response = self.stub.Healthcheck( 6547 req, 6548 metadata=self.parent.get_metadata( 6549 'SecretStoreHealths.Healthcheck', req), 6550 timeout=t) 6551 except Exception as e: 6552 if self.parent.shouldRetry(tries, e, deadline): 6553 tries += 1 6554 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6555 continue 6556 raise plumbing.convert_error_to_porcelain(e) from e 6557 break 6558 6559 resp = models.SecretStoreHealthcheckResponse() 6560 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6561 plumbing_response.rate_limit) 6562 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
6490 def list(self, filter, *args, timeout=None): 6491 ''' 6492 List reports the health status of node to secret store pairs. 6493 ''' 6494 deadline = None if timeout is None else time.time() + timeout 6495 req = SecretStoreHealthListRequest() 6496 req.meta.CopyFrom(ListRequestMetadata()) 6497 if self.parent.page_limit > 0: 6498 req.meta.limit = self.parent.page_limit 6499 if self.parent.snapshot_datetime is not None: 6500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6501 6502 req.filter = plumbing.quote_filter_args(filter, *args) 6503 6504 def generator(svc, req): 6505 tries = 0 6506 while True: 6507 t = None if deadline is None else deadline - time.time() 6508 try: 6509 plumbing_response = svc.stub.List( 6510 req, 6511 metadata=svc.parent.get_metadata( 6512 'SecretStoreHealths.List', req), 6513 timeout=t) 6514 except Exception as e: 6515 if self.parent.shouldRetry(tries, e, deadline): 6516 tries += 1 6517 time.sleep( 6518 self.parent.exponentialBackoff(tries, deadline)) 6519 continue 6520 raise plumbing.convert_error_to_porcelain(e) from e 6521 tries = 0 6522 for plumbing_item in plumbing_response.secret_store_healths: 6523 yield plumbing.convert_secret_store_health_to_porcelain( 6524 plumbing_item) 6525 if plumbing_response.meta.next_cursor == '': 6526 break 6527 req.meta.cursor = plumbing_response.meta.next_cursor 6528 6529 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
6531 def healthcheck(self, secret_store_id, timeout=None): 6532 ''' 6533 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6534 to propagate across a large network of Nodes. The call will return immediately, and the 6535 updated health of the Secret Store can be retrieved via List. 6536 ''' 6537 deadline = None if timeout is None else time.time() + timeout 6538 req = SecretStoreHealthcheckRequest() 6539 6540 req.secret_store_id = (secret_store_id) 6541 tries = 0 6542 plumbing_response = None 6543 while True: 6544 t = None if deadline is None else deadline - time.time() 6545 try: 6546 plumbing_response = self.stub.Healthcheck( 6547 req, 6548 metadata=self.parent.get_metadata( 6549 'SecretStoreHealths.Healthcheck', req), 6550 timeout=t) 6551 except Exception as e: 6552 if self.parent.shouldRetry(tries, e, deadline): 6553 tries += 1 6554 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6555 continue 6556 raise plumbing.convert_error_to_porcelain(e) from e 6557 break 6558 6559 resp = models.SecretStoreHealthcheckResponse() 6560 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6561 plumbing_response.rate_limit) 6562 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:
6565class SecretStoresHistory: 6566 ''' 6567 SecretStoresHistory records all changes to the state of a SecretStore. 6568 See `strongdm.models.SecretStoreHistory`. 6569 ''' 6570 def __init__(self, channel, client): 6571 self.parent = client 6572 self.stub = SecretStoresHistoryStub(channel) 6573 6574 def list(self, filter, *args, timeout=None): 6575 ''' 6576 List gets a list of SecretStoreHistory records matching a given set of criteria. 6577 ''' 6578 deadline = None if timeout is None else time.time() + timeout 6579 req = SecretStoreHistoryListRequest() 6580 req.meta.CopyFrom(ListRequestMetadata()) 6581 if self.parent.page_limit > 0: 6582 req.meta.limit = self.parent.page_limit 6583 if self.parent.snapshot_datetime is not None: 6584 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6585 6586 req.filter = plumbing.quote_filter_args(filter, *args) 6587 6588 def generator(svc, req): 6589 tries = 0 6590 while True: 6591 t = None if deadline is None else deadline - time.time() 6592 try: 6593 plumbing_response = svc.stub.List( 6594 req, 6595 metadata=svc.parent.get_metadata( 6596 'SecretStoresHistory.List', req), 6597 timeout=t) 6598 except Exception as e: 6599 if self.parent.shouldRetry(tries, e, deadline): 6600 tries += 1 6601 time.sleep( 6602 self.parent.exponentialBackoff(tries, deadline)) 6603 continue 6604 raise plumbing.convert_error_to_porcelain(e) from e 6605 tries = 0 6606 for plumbing_item in plumbing_response.history: 6607 yield plumbing.convert_secret_store_history_to_porcelain( 6608 plumbing_item) 6609 if plumbing_response.meta.next_cursor == '': 6610 break 6611 req.meta.cursor = plumbing_response.meta.next_cursor 6612 6613 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)
6574 def list(self, filter, *args, timeout=None): 6575 ''' 6576 List gets a list of SecretStoreHistory records matching a given set of criteria. 6577 ''' 6578 deadline = None if timeout is None else time.time() + timeout 6579 req = SecretStoreHistoryListRequest() 6580 req.meta.CopyFrom(ListRequestMetadata()) 6581 if self.parent.page_limit > 0: 6582 req.meta.limit = self.parent.page_limit 6583 if self.parent.snapshot_datetime is not None: 6584 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6585 6586 req.filter = plumbing.quote_filter_args(filter, *args) 6587 6588 def generator(svc, req): 6589 tries = 0 6590 while True: 6591 t = None if deadline is None else deadline - time.time() 6592 try: 6593 plumbing_response = svc.stub.List( 6594 req, 6595 metadata=svc.parent.get_metadata( 6596 'SecretStoresHistory.List', req), 6597 timeout=t) 6598 except Exception as e: 6599 if self.parent.shouldRetry(tries, e, deadline): 6600 tries += 1 6601 time.sleep( 6602 self.parent.exponentialBackoff(tries, deadline)) 6603 continue 6604 raise plumbing.convert_error_to_porcelain(e) from e 6605 tries = 0 6606 for plumbing_item in plumbing_response.history: 6607 yield plumbing.convert_secret_store_history_to_porcelain( 6608 plumbing_item) 6609 if plumbing_response.meta.next_cursor == '': 6610 break 6611 req.meta.cursor = plumbing_response.meta.next_cursor 6612 6613 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
6616class WorkflowApprovers: 6617 ''' 6618 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6619 See `strongdm.models.WorkflowApprover`. 6620 ''' 6621 def __init__(self, channel, client): 6622 self.parent = client 6623 self.stub = WorkflowApproversStub(channel) 6624 6625 def create(self, workflow_approver, timeout=None): 6626 ''' 6627 Create creates a new workflow approver 6628 ''' 6629 deadline = None if timeout is None else time.time() + timeout 6630 req = WorkflowApproversCreateRequest() 6631 6632 if workflow_approver is not None: 6633 req.workflow_approver.CopyFrom( 6634 plumbing.convert_workflow_approver_to_plumbing( 6635 workflow_approver)) 6636 tries = 0 6637 plumbing_response = None 6638 while True: 6639 t = None if deadline is None else deadline - time.time() 6640 try: 6641 plumbing_response = self.stub.Create( 6642 req, 6643 metadata=self.parent.get_metadata( 6644 'WorkflowApprovers.Create', req), 6645 timeout=t) 6646 except Exception as e: 6647 if self.parent.shouldRetry(tries, e, deadline): 6648 tries += 1 6649 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6650 continue 6651 raise plumbing.convert_error_to_porcelain(e) from e 6652 break 6653 6654 resp = models.WorkflowApproversCreateResponse() 6655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6656 plumbing_response.rate_limit) 6657 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6658 plumbing_response.workflow_approver) 6659 return resp 6660 6661 def get(self, id, timeout=None): 6662 ''' 6663 Get reads one workflow approver by ID. 6664 ''' 6665 deadline = None if timeout is None else time.time() + timeout 6666 req = WorkflowApproverGetRequest() 6667 if self.parent.snapshot_datetime is not None: 6668 req.meta.CopyFrom(GetRequestMetadata()) 6669 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6670 6671 req.id = (id) 6672 tries = 0 6673 plumbing_response = None 6674 while True: 6675 t = None if deadline is None else deadline - time.time() 6676 try: 6677 plumbing_response = self.stub.Get( 6678 req, 6679 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6680 req), 6681 timeout=t) 6682 except Exception as e: 6683 if self.parent.shouldRetry(tries, e, deadline): 6684 tries += 1 6685 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6686 continue 6687 raise plumbing.convert_error_to_porcelain(e) from e 6688 break 6689 6690 resp = models.WorkflowApproverGetResponse() 6691 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6692 plumbing_response.meta) 6693 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6694 plumbing_response.rate_limit) 6695 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6696 plumbing_response.workflow_approver) 6697 return resp 6698 6699 def delete(self, id, timeout=None): 6700 ''' 6701 Delete deletes a workflow approver 6702 ''' 6703 deadline = None if timeout is None else time.time() + timeout 6704 req = WorkflowApproversDeleteRequest() 6705 6706 req.id = (id) 6707 tries = 0 6708 plumbing_response = None 6709 while True: 6710 t = None if deadline is None else deadline - time.time() 6711 try: 6712 plumbing_response = self.stub.Delete( 6713 req, 6714 metadata=self.parent.get_metadata( 6715 'WorkflowApprovers.Delete', req), 6716 timeout=t) 6717 except Exception as e: 6718 if self.parent.shouldRetry(tries, e, deadline): 6719 tries += 1 6720 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6721 continue 6722 raise plumbing.convert_error_to_porcelain(e) from e 6723 break 6724 6725 resp = models.WorkflowApproversDeleteResponse() 6726 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6727 plumbing_response.rate_limit) 6728 return resp 6729 6730 def list(self, filter, *args, timeout=None): 6731 ''' 6732 Lists existing workflow approvers. 6733 ''' 6734 deadline = None if timeout is None else time.time() + timeout 6735 req = WorkflowApproversListRequest() 6736 req.meta.CopyFrom(ListRequestMetadata()) 6737 if self.parent.page_limit > 0: 6738 req.meta.limit = self.parent.page_limit 6739 if self.parent.snapshot_datetime is not None: 6740 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6741 6742 req.filter = plumbing.quote_filter_args(filter, *args) 6743 6744 def generator(svc, req): 6745 tries = 0 6746 while True: 6747 t = None if deadline is None else deadline - time.time() 6748 try: 6749 plumbing_response = svc.stub.List( 6750 req, 6751 metadata=svc.parent.get_metadata( 6752 'WorkflowApprovers.List', req), 6753 timeout=t) 6754 except Exception as e: 6755 if self.parent.shouldRetry(tries, e, deadline): 6756 tries += 1 6757 time.sleep( 6758 self.parent.exponentialBackoff(tries, deadline)) 6759 continue 6760 raise plumbing.convert_error_to_porcelain(e) from e 6761 tries = 0 6762 for plumbing_item in plumbing_response.workflow_approvers: 6763 yield plumbing.convert_workflow_approver_to_porcelain( 6764 plumbing_item) 6765 if plumbing_response.meta.next_cursor == '': 6766 break 6767 req.meta.cursor = plumbing_response.meta.next_cursor 6768 6769 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)
6625 def create(self, workflow_approver, timeout=None): 6626 ''' 6627 Create creates a new workflow approver 6628 ''' 6629 deadline = None if timeout is None else time.time() + timeout 6630 req = WorkflowApproversCreateRequest() 6631 6632 if workflow_approver is not None: 6633 req.workflow_approver.CopyFrom( 6634 plumbing.convert_workflow_approver_to_plumbing( 6635 workflow_approver)) 6636 tries = 0 6637 plumbing_response = None 6638 while True: 6639 t = None if deadline is None else deadline - time.time() 6640 try: 6641 plumbing_response = self.stub.Create( 6642 req, 6643 metadata=self.parent.get_metadata( 6644 'WorkflowApprovers.Create', req), 6645 timeout=t) 6646 except Exception as e: 6647 if self.parent.shouldRetry(tries, e, deadline): 6648 tries += 1 6649 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6650 continue 6651 raise plumbing.convert_error_to_porcelain(e) from e 6652 break 6653 6654 resp = models.WorkflowApproversCreateResponse() 6655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6656 plumbing_response.rate_limit) 6657 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6658 plumbing_response.workflow_approver) 6659 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
6661 def get(self, id, timeout=None): 6662 ''' 6663 Get reads one workflow approver by ID. 6664 ''' 6665 deadline = None if timeout is None else time.time() + timeout 6666 req = WorkflowApproverGetRequest() 6667 if self.parent.snapshot_datetime is not None: 6668 req.meta.CopyFrom(GetRequestMetadata()) 6669 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6670 6671 req.id = (id) 6672 tries = 0 6673 plumbing_response = None 6674 while True: 6675 t = None if deadline is None else deadline - time.time() 6676 try: 6677 plumbing_response = self.stub.Get( 6678 req, 6679 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6680 req), 6681 timeout=t) 6682 except Exception as e: 6683 if self.parent.shouldRetry(tries, e, deadline): 6684 tries += 1 6685 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6686 continue 6687 raise plumbing.convert_error_to_porcelain(e) from e 6688 break 6689 6690 resp = models.WorkflowApproverGetResponse() 6691 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6692 plumbing_response.meta) 6693 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6694 plumbing_response.rate_limit) 6695 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6696 plumbing_response.workflow_approver) 6697 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
6699 def delete(self, id, timeout=None): 6700 ''' 6701 Delete deletes a workflow approver 6702 ''' 6703 deadline = None if timeout is None else time.time() + timeout 6704 req = WorkflowApproversDeleteRequest() 6705 6706 req.id = (id) 6707 tries = 0 6708 plumbing_response = None 6709 while True: 6710 t = None if deadline is None else deadline - time.time() 6711 try: 6712 plumbing_response = self.stub.Delete( 6713 req, 6714 metadata=self.parent.get_metadata( 6715 'WorkflowApprovers.Delete', req), 6716 timeout=t) 6717 except Exception as e: 6718 if self.parent.shouldRetry(tries, e, deadline): 6719 tries += 1 6720 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6721 continue 6722 raise plumbing.convert_error_to_porcelain(e) from e 6723 break 6724 6725 resp = models.WorkflowApproversDeleteResponse() 6726 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6727 plumbing_response.rate_limit) 6728 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
6730 def list(self, filter, *args, timeout=None): 6731 ''' 6732 Lists existing workflow approvers. 6733 ''' 6734 deadline = None if timeout is None else time.time() + timeout 6735 req = WorkflowApproversListRequest() 6736 req.meta.CopyFrom(ListRequestMetadata()) 6737 if self.parent.page_limit > 0: 6738 req.meta.limit = self.parent.page_limit 6739 if self.parent.snapshot_datetime is not None: 6740 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6741 6742 req.filter = plumbing.quote_filter_args(filter, *args) 6743 6744 def generator(svc, req): 6745 tries = 0 6746 while True: 6747 t = None if deadline is None else deadline - time.time() 6748 try: 6749 plumbing_response = svc.stub.List( 6750 req, 6751 metadata=svc.parent.get_metadata( 6752 'WorkflowApprovers.List', req), 6753 timeout=t) 6754 except Exception as e: 6755 if self.parent.shouldRetry(tries, e, deadline): 6756 tries += 1 6757 time.sleep( 6758 self.parent.exponentialBackoff(tries, deadline)) 6759 continue 6760 raise plumbing.convert_error_to_porcelain(e) from e 6761 tries = 0 6762 for plumbing_item in plumbing_response.workflow_approvers: 6763 yield plumbing.convert_workflow_approver_to_porcelain( 6764 plumbing_item) 6765 if plumbing_response.meta.next_cursor == '': 6766 break 6767 req.meta.cursor = plumbing_response.meta.next_cursor 6768 6769 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
6772class SnapshotWorkflowApprovers: 6773 ''' 6774 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6775 service for historical queries. 6776 ''' 6777 def __init__(self, workflow_approvers): 6778 self.workflow_approvers = workflow_approvers 6779 6780 def get(self, id, timeout=None): 6781 ''' 6782 Get reads one workflow approver by ID. 6783 ''' 6784 return self.workflow_approvers.get(id, timeout=timeout) 6785 6786 def list(self, filter, *args, timeout=None): 6787 ''' 6788 Lists existing workflow approvers. 6789 ''' 6790 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
6793class WorkflowApproversHistory: 6794 ''' 6795 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6796 See `strongdm.models.WorkflowApproverHistory`. 6797 ''' 6798 def __init__(self, channel, client): 6799 self.parent = client 6800 self.stub = WorkflowApproversHistoryStub(channel) 6801 6802 def list(self, filter, *args, timeout=None): 6803 ''' 6804 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6805 ''' 6806 deadline = None if timeout is None else time.time() + timeout 6807 req = WorkflowApproversHistoryListRequest() 6808 req.meta.CopyFrom(ListRequestMetadata()) 6809 if self.parent.page_limit > 0: 6810 req.meta.limit = self.parent.page_limit 6811 if self.parent.snapshot_datetime is not None: 6812 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6813 6814 req.filter = plumbing.quote_filter_args(filter, *args) 6815 6816 def generator(svc, req): 6817 tries = 0 6818 while True: 6819 t = None if deadline is None else deadline - time.time() 6820 try: 6821 plumbing_response = svc.stub.List( 6822 req, 6823 metadata=svc.parent.get_metadata( 6824 'WorkflowApproversHistory.List', req), 6825 timeout=t) 6826 except Exception as e: 6827 if self.parent.shouldRetry(tries, e, deadline): 6828 tries += 1 6829 time.sleep( 6830 self.parent.exponentialBackoff(tries, deadline)) 6831 continue 6832 raise plumbing.convert_error_to_porcelain(e) from e 6833 tries = 0 6834 for plumbing_item in plumbing_response.history: 6835 yield plumbing.convert_workflow_approver_history_to_porcelain( 6836 plumbing_item) 6837 if plumbing_response.meta.next_cursor == '': 6838 break 6839 req.meta.cursor = plumbing_response.meta.next_cursor 6840 6841 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)
6802 def list(self, filter, *args, timeout=None): 6803 ''' 6804 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6805 ''' 6806 deadline = None if timeout is None else time.time() + timeout 6807 req = WorkflowApproversHistoryListRequest() 6808 req.meta.CopyFrom(ListRequestMetadata()) 6809 if self.parent.page_limit > 0: 6810 req.meta.limit = self.parent.page_limit 6811 if self.parent.snapshot_datetime is not None: 6812 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6813 6814 req.filter = plumbing.quote_filter_args(filter, *args) 6815 6816 def generator(svc, req): 6817 tries = 0 6818 while True: 6819 t = None if deadline is None else deadline - time.time() 6820 try: 6821 plumbing_response = svc.stub.List( 6822 req, 6823 metadata=svc.parent.get_metadata( 6824 'WorkflowApproversHistory.List', req), 6825 timeout=t) 6826 except Exception as e: 6827 if self.parent.shouldRetry(tries, e, deadline): 6828 tries += 1 6829 time.sleep( 6830 self.parent.exponentialBackoff(tries, deadline)) 6831 continue 6832 raise plumbing.convert_error_to_porcelain(e) from e 6833 tries = 0 6834 for plumbing_item in plumbing_response.history: 6835 yield plumbing.convert_workflow_approver_history_to_porcelain( 6836 plumbing_item) 6837 if plumbing_response.meta.next_cursor == '': 6838 break 6839 req.meta.cursor = plumbing_response.meta.next_cursor 6840 6841 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowAssignments:
6844class WorkflowAssignments: 6845 ''' 6846 WorkflowAssignments links a Resource to a Workflow. The assigned resources are those that a user can request 6847 access to via the workflow. 6848 See `strongdm.models.WorkflowAssignment`. 6849 ''' 6850 def __init__(self, channel, client): 6851 self.parent = client 6852 self.stub = WorkflowAssignmentsStub(channel) 6853 6854 def list(self, filter, *args, timeout=None): 6855 ''' 6856 Lists existing workflow assignments. 6857 ''' 6858 deadline = None if timeout is None else time.time() + timeout 6859 req = WorkflowAssignmentsListRequest() 6860 req.meta.CopyFrom(ListRequestMetadata()) 6861 if self.parent.page_limit > 0: 6862 req.meta.limit = self.parent.page_limit 6863 if self.parent.snapshot_datetime is not None: 6864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6865 6866 req.filter = plumbing.quote_filter_args(filter, *args) 6867 6868 def generator(svc, req): 6869 tries = 0 6870 while True: 6871 t = None if deadline is None else deadline - time.time() 6872 try: 6873 plumbing_response = svc.stub.List( 6874 req, 6875 metadata=svc.parent.get_metadata( 6876 'WorkflowAssignments.List', req), 6877 timeout=t) 6878 except Exception as e: 6879 if self.parent.shouldRetry(tries, e, deadline): 6880 tries += 1 6881 time.sleep( 6882 self.parent.exponentialBackoff(tries, deadline)) 6883 continue 6884 raise plumbing.convert_error_to_porcelain(e) from e 6885 tries = 0 6886 for plumbing_item in plumbing_response.workflow_assignments: 6887 yield plumbing.convert_workflow_assignment_to_porcelain( 6888 plumbing_item) 6889 if plumbing_response.meta.next_cursor == '': 6890 break 6891 req.meta.cursor = plumbing_response.meta.next_cursor 6892 6893 return generator(self, req)
WorkflowAssignments links a Resource to a Workflow. The assigned resources are those that a user can request
access to via the workflow.
See strongdm.models.WorkflowAssignment.
def
list(self, filter, *args, timeout=None)
6854 def list(self, filter, *args, timeout=None): 6855 ''' 6856 Lists existing workflow assignments. 6857 ''' 6858 deadline = None if timeout is None else time.time() + timeout 6859 req = WorkflowAssignmentsListRequest() 6860 req.meta.CopyFrom(ListRequestMetadata()) 6861 if self.parent.page_limit > 0: 6862 req.meta.limit = self.parent.page_limit 6863 if self.parent.snapshot_datetime is not None: 6864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6865 6866 req.filter = plumbing.quote_filter_args(filter, *args) 6867 6868 def generator(svc, req): 6869 tries = 0 6870 while True: 6871 t = None if deadline is None else deadline - time.time() 6872 try: 6873 plumbing_response = svc.stub.List( 6874 req, 6875 metadata=svc.parent.get_metadata( 6876 'WorkflowAssignments.List', req), 6877 timeout=t) 6878 except Exception as e: 6879 if self.parent.shouldRetry(tries, e, deadline): 6880 tries += 1 6881 time.sleep( 6882 self.parent.exponentialBackoff(tries, deadline)) 6883 continue 6884 raise plumbing.convert_error_to_porcelain(e) from e 6885 tries = 0 6886 for plumbing_item in plumbing_response.workflow_assignments: 6887 yield plumbing.convert_workflow_assignment_to_porcelain( 6888 plumbing_item) 6889 if plumbing_response.meta.next_cursor == '': 6890 break 6891 req.meta.cursor = plumbing_response.meta.next_cursor 6892 6893 return generator(self, req)
Lists existing workflow assignments.
class
SnapshotWorkflowAssignments:
6896class SnapshotWorkflowAssignments: 6897 ''' 6898 SnapshotWorkflowAssignments exposes the read only methods of the WorkflowAssignments 6899 service for historical queries. 6900 ''' 6901 def __init__(self, workflow_assignments): 6902 self.workflow_assignments = workflow_assignments 6903 6904 def list(self, filter, *args, timeout=None): 6905 ''' 6906 Lists existing workflow assignments. 6907 ''' 6908 return self.workflow_assignments.list(filter, *args, timeout=timeout)
SnapshotWorkflowAssignments exposes the read only methods of the WorkflowAssignments service for historical queries.
class
WorkflowAssignmentsHistory:
6911class WorkflowAssignmentsHistory: 6912 ''' 6913 WorkflowAssignmentsHistory provides records of all changes to the state of a WorkflowAssignment. 6914 See `strongdm.models.WorkflowAssignmentHistory`. 6915 ''' 6916 def __init__(self, channel, client): 6917 self.parent = client 6918 self.stub = WorkflowAssignmentsHistoryStub(channel) 6919 6920 def list(self, filter, *args, timeout=None): 6921 ''' 6922 List gets a list of WorkflowAssignmentsHistory records matching a given set of criteria. 6923 ''' 6924 deadline = None if timeout is None else time.time() + timeout 6925 req = WorkflowAssignmentsHistoryListRequest() 6926 req.meta.CopyFrom(ListRequestMetadata()) 6927 if self.parent.page_limit > 0: 6928 req.meta.limit = self.parent.page_limit 6929 if self.parent.snapshot_datetime is not None: 6930 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6931 6932 req.filter = plumbing.quote_filter_args(filter, *args) 6933 6934 def generator(svc, req): 6935 tries = 0 6936 while True: 6937 t = None if deadline is None else deadline - time.time() 6938 try: 6939 plumbing_response = svc.stub.List( 6940 req, 6941 metadata=svc.parent.get_metadata( 6942 'WorkflowAssignmentsHistory.List', req), 6943 timeout=t) 6944 except Exception as e: 6945 if self.parent.shouldRetry(tries, e, deadline): 6946 tries += 1 6947 time.sleep( 6948 self.parent.exponentialBackoff(tries, deadline)) 6949 continue 6950 raise plumbing.convert_error_to_porcelain(e) from e 6951 tries = 0 6952 for plumbing_item in plumbing_response.history: 6953 yield plumbing.convert_workflow_assignment_history_to_porcelain( 6954 plumbing_item) 6955 if plumbing_response.meta.next_cursor == '': 6956 break 6957 req.meta.cursor = plumbing_response.meta.next_cursor 6958 6959 return generator(self, req)
WorkflowAssignmentsHistory provides records of all changes to the state of a WorkflowAssignment.
See strongdm.models.WorkflowAssignmentHistory.
def
list(self, filter, *args, timeout=None)
6920 def list(self, filter, *args, timeout=None): 6921 ''' 6922 List gets a list of WorkflowAssignmentsHistory records matching a given set of criteria. 6923 ''' 6924 deadline = None if timeout is None else time.time() + timeout 6925 req = WorkflowAssignmentsHistoryListRequest() 6926 req.meta.CopyFrom(ListRequestMetadata()) 6927 if self.parent.page_limit > 0: 6928 req.meta.limit = self.parent.page_limit 6929 if self.parent.snapshot_datetime is not None: 6930 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6931 6932 req.filter = plumbing.quote_filter_args(filter, *args) 6933 6934 def generator(svc, req): 6935 tries = 0 6936 while True: 6937 t = None if deadline is None else deadline - time.time() 6938 try: 6939 plumbing_response = svc.stub.List( 6940 req, 6941 metadata=svc.parent.get_metadata( 6942 'WorkflowAssignmentsHistory.List', req), 6943 timeout=t) 6944 except Exception as e: 6945 if self.parent.shouldRetry(tries, e, deadline): 6946 tries += 1 6947 time.sleep( 6948 self.parent.exponentialBackoff(tries, deadline)) 6949 continue 6950 raise plumbing.convert_error_to_porcelain(e) from e 6951 tries = 0 6952 for plumbing_item in plumbing_response.history: 6953 yield plumbing.convert_workflow_assignment_history_to_porcelain( 6954 plumbing_item) 6955 if plumbing_response.meta.next_cursor == '': 6956 break 6957 req.meta.cursor = plumbing_response.meta.next_cursor 6958 6959 return generator(self, req)
List gets a list of WorkflowAssignmentsHistory records matching a given set of criteria.
class
WorkflowRoles:
6962class WorkflowRoles: 6963 ''' 6964 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6965 to request access to a resource via the workflow. 6966 See `strongdm.models.WorkflowRole`. 6967 ''' 6968 def __init__(self, channel, client): 6969 self.parent = client 6970 self.stub = WorkflowRolesStub(channel) 6971 6972 def create(self, workflow_role, timeout=None): 6973 ''' 6974 Create creates a new workflow role 6975 ''' 6976 deadline = None if timeout is None else time.time() + timeout 6977 req = WorkflowRolesCreateRequest() 6978 6979 if workflow_role is not None: 6980 req.workflow_role.CopyFrom( 6981 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6982 tries = 0 6983 plumbing_response = None 6984 while True: 6985 t = None if deadline is None else deadline - time.time() 6986 try: 6987 plumbing_response = self.stub.Create( 6988 req, 6989 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6990 req), 6991 timeout=t) 6992 except Exception as e: 6993 if self.parent.shouldRetry(tries, e, deadline): 6994 tries += 1 6995 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6996 continue 6997 raise plumbing.convert_error_to_porcelain(e) from e 6998 break 6999 7000 resp = models.WorkflowRolesCreateResponse() 7001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7002 plumbing_response.rate_limit) 7003 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7004 plumbing_response.workflow_role) 7005 return resp 7006 7007 def get(self, id, timeout=None): 7008 ''' 7009 Get reads one workflow role by ID. 7010 ''' 7011 deadline = None if timeout is None else time.time() + timeout 7012 req = WorkflowRoleGetRequest() 7013 if self.parent.snapshot_datetime is not None: 7014 req.meta.CopyFrom(GetRequestMetadata()) 7015 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7016 7017 req.id = (id) 7018 tries = 0 7019 plumbing_response = None 7020 while True: 7021 t = None if deadline is None else deadline - time.time() 7022 try: 7023 plumbing_response = self.stub.Get( 7024 req, 7025 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7026 req), 7027 timeout=t) 7028 except Exception as e: 7029 if self.parent.shouldRetry(tries, e, deadline): 7030 tries += 1 7031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7032 continue 7033 raise plumbing.convert_error_to_porcelain(e) from e 7034 break 7035 7036 resp = models.WorkflowRoleGetResponse() 7037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7038 plumbing_response.meta) 7039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7040 plumbing_response.rate_limit) 7041 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7042 plumbing_response.workflow_role) 7043 return resp 7044 7045 def delete(self, id, timeout=None): 7046 ''' 7047 Delete deletes a workflow role 7048 ''' 7049 deadline = None if timeout is None else time.time() + timeout 7050 req = WorkflowRolesDeleteRequest() 7051 7052 req.id = (id) 7053 tries = 0 7054 plumbing_response = None 7055 while True: 7056 t = None if deadline is None else deadline - time.time() 7057 try: 7058 plumbing_response = self.stub.Delete( 7059 req, 7060 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7061 req), 7062 timeout=t) 7063 except Exception as e: 7064 if self.parent.shouldRetry(tries, e, deadline): 7065 tries += 1 7066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7067 continue 7068 raise plumbing.convert_error_to_porcelain(e) from e 7069 break 7070 7071 resp = models.WorkflowRolesDeleteResponse() 7072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7073 plumbing_response.rate_limit) 7074 return resp 7075 7076 def list(self, filter, *args, timeout=None): 7077 ''' 7078 Lists existing workflow roles. 7079 ''' 7080 deadline = None if timeout is None else time.time() + timeout 7081 req = WorkflowRolesListRequest() 7082 req.meta.CopyFrom(ListRequestMetadata()) 7083 if self.parent.page_limit > 0: 7084 req.meta.limit = self.parent.page_limit 7085 if self.parent.snapshot_datetime is not None: 7086 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7087 7088 req.filter = plumbing.quote_filter_args(filter, *args) 7089 7090 def generator(svc, req): 7091 tries = 0 7092 while True: 7093 t = None if deadline is None else deadline - time.time() 7094 try: 7095 plumbing_response = svc.stub.List( 7096 req, 7097 metadata=svc.parent.get_metadata( 7098 'WorkflowRoles.List', req), 7099 timeout=t) 7100 except Exception as e: 7101 if self.parent.shouldRetry(tries, e, deadline): 7102 tries += 1 7103 time.sleep( 7104 self.parent.exponentialBackoff(tries, deadline)) 7105 continue 7106 raise plumbing.convert_error_to_porcelain(e) from e 7107 tries = 0 7108 for plumbing_item in plumbing_response.workflow_role: 7109 yield plumbing.convert_workflow_role_to_porcelain( 7110 plumbing_item) 7111 if plumbing_response.meta.next_cursor == '': 7112 break 7113 req.meta.cursor = plumbing_response.meta.next_cursor 7114 7115 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)
6972 def create(self, workflow_role, timeout=None): 6973 ''' 6974 Create creates a new workflow role 6975 ''' 6976 deadline = None if timeout is None else time.time() + timeout 6977 req = WorkflowRolesCreateRequest() 6978 6979 if workflow_role is not None: 6980 req.workflow_role.CopyFrom( 6981 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6982 tries = 0 6983 plumbing_response = None 6984 while True: 6985 t = None if deadline is None else deadline - time.time() 6986 try: 6987 plumbing_response = self.stub.Create( 6988 req, 6989 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6990 req), 6991 timeout=t) 6992 except Exception as e: 6993 if self.parent.shouldRetry(tries, e, deadline): 6994 tries += 1 6995 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6996 continue 6997 raise plumbing.convert_error_to_porcelain(e) from e 6998 break 6999 7000 resp = models.WorkflowRolesCreateResponse() 7001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7002 plumbing_response.rate_limit) 7003 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7004 plumbing_response.workflow_role) 7005 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
7007 def get(self, id, timeout=None): 7008 ''' 7009 Get reads one workflow role by ID. 7010 ''' 7011 deadline = None if timeout is None else time.time() + timeout 7012 req = WorkflowRoleGetRequest() 7013 if self.parent.snapshot_datetime is not None: 7014 req.meta.CopyFrom(GetRequestMetadata()) 7015 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7016 7017 req.id = (id) 7018 tries = 0 7019 plumbing_response = None 7020 while True: 7021 t = None if deadline is None else deadline - time.time() 7022 try: 7023 plumbing_response = self.stub.Get( 7024 req, 7025 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7026 req), 7027 timeout=t) 7028 except Exception as e: 7029 if self.parent.shouldRetry(tries, e, deadline): 7030 tries += 1 7031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7032 continue 7033 raise plumbing.convert_error_to_porcelain(e) from e 7034 break 7035 7036 resp = models.WorkflowRoleGetResponse() 7037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7038 plumbing_response.meta) 7039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7040 plumbing_response.rate_limit) 7041 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7042 plumbing_response.workflow_role) 7043 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
7045 def delete(self, id, timeout=None): 7046 ''' 7047 Delete deletes a workflow role 7048 ''' 7049 deadline = None if timeout is None else time.time() + timeout 7050 req = WorkflowRolesDeleteRequest() 7051 7052 req.id = (id) 7053 tries = 0 7054 plumbing_response = None 7055 while True: 7056 t = None if deadline is None else deadline - time.time() 7057 try: 7058 plumbing_response = self.stub.Delete( 7059 req, 7060 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7061 req), 7062 timeout=t) 7063 except Exception as e: 7064 if self.parent.shouldRetry(tries, e, deadline): 7065 tries += 1 7066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7067 continue 7068 raise plumbing.convert_error_to_porcelain(e) from e 7069 break 7070 7071 resp = models.WorkflowRolesDeleteResponse() 7072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7073 plumbing_response.rate_limit) 7074 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
7076 def list(self, filter, *args, timeout=None): 7077 ''' 7078 Lists existing workflow roles. 7079 ''' 7080 deadline = None if timeout is None else time.time() + timeout 7081 req = WorkflowRolesListRequest() 7082 req.meta.CopyFrom(ListRequestMetadata()) 7083 if self.parent.page_limit > 0: 7084 req.meta.limit = self.parent.page_limit 7085 if self.parent.snapshot_datetime is not None: 7086 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7087 7088 req.filter = plumbing.quote_filter_args(filter, *args) 7089 7090 def generator(svc, req): 7091 tries = 0 7092 while True: 7093 t = None if deadline is None else deadline - time.time() 7094 try: 7095 plumbing_response = svc.stub.List( 7096 req, 7097 metadata=svc.parent.get_metadata( 7098 'WorkflowRoles.List', req), 7099 timeout=t) 7100 except Exception as e: 7101 if self.parent.shouldRetry(tries, e, deadline): 7102 tries += 1 7103 time.sleep( 7104 self.parent.exponentialBackoff(tries, deadline)) 7105 continue 7106 raise plumbing.convert_error_to_porcelain(e) from e 7107 tries = 0 7108 for plumbing_item in plumbing_response.workflow_role: 7109 yield plumbing.convert_workflow_role_to_porcelain( 7110 plumbing_item) 7111 if plumbing_response.meta.next_cursor == '': 7112 break 7113 req.meta.cursor = plumbing_response.meta.next_cursor 7114 7115 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
7118class SnapshotWorkflowRoles: 7119 ''' 7120 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7121 service for historical queries. 7122 ''' 7123 def __init__(self, workflow_roles): 7124 self.workflow_roles = workflow_roles 7125 7126 def get(self, id, timeout=None): 7127 ''' 7128 Get reads one workflow role by ID. 7129 ''' 7130 return self.workflow_roles.get(id, timeout=timeout) 7131 7132 def list(self, filter, *args, timeout=None): 7133 ''' 7134 Lists existing workflow roles. 7135 ''' 7136 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
7139class WorkflowRolesHistory: 7140 ''' 7141 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7142 See `strongdm.models.WorkflowRoleHistory`. 7143 ''' 7144 def __init__(self, channel, client): 7145 self.parent = client 7146 self.stub = WorkflowRolesHistoryStub(channel) 7147 7148 def list(self, filter, *args, timeout=None): 7149 ''' 7150 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7151 ''' 7152 deadline = None if timeout is None else time.time() + timeout 7153 req = WorkflowRolesHistoryListRequest() 7154 req.meta.CopyFrom(ListRequestMetadata()) 7155 if self.parent.page_limit > 0: 7156 req.meta.limit = self.parent.page_limit 7157 if self.parent.snapshot_datetime is not None: 7158 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7159 7160 req.filter = plumbing.quote_filter_args(filter, *args) 7161 7162 def generator(svc, req): 7163 tries = 0 7164 while True: 7165 t = None if deadline is None else deadline - time.time() 7166 try: 7167 plumbing_response = svc.stub.List( 7168 req, 7169 metadata=svc.parent.get_metadata( 7170 'WorkflowRolesHistory.List', req), 7171 timeout=t) 7172 except Exception as e: 7173 if self.parent.shouldRetry(tries, e, deadline): 7174 tries += 1 7175 time.sleep( 7176 self.parent.exponentialBackoff(tries, deadline)) 7177 continue 7178 raise plumbing.convert_error_to_porcelain(e) from e 7179 tries = 0 7180 for plumbing_item in plumbing_response.history: 7181 yield plumbing.convert_workflow_role_history_to_porcelain( 7182 plumbing_item) 7183 if plumbing_response.meta.next_cursor == '': 7184 break 7185 req.meta.cursor = plumbing_response.meta.next_cursor 7186 7187 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)
7148 def list(self, filter, *args, timeout=None): 7149 ''' 7150 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7151 ''' 7152 deadline = None if timeout is None else time.time() + timeout 7153 req = WorkflowRolesHistoryListRequest() 7154 req.meta.CopyFrom(ListRequestMetadata()) 7155 if self.parent.page_limit > 0: 7156 req.meta.limit = self.parent.page_limit 7157 if self.parent.snapshot_datetime is not None: 7158 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7159 7160 req.filter = plumbing.quote_filter_args(filter, *args) 7161 7162 def generator(svc, req): 7163 tries = 0 7164 while True: 7165 t = None if deadline is None else deadline - time.time() 7166 try: 7167 plumbing_response = svc.stub.List( 7168 req, 7169 metadata=svc.parent.get_metadata( 7170 'WorkflowRolesHistory.List', req), 7171 timeout=t) 7172 except Exception as e: 7173 if self.parent.shouldRetry(tries, e, deadline): 7174 tries += 1 7175 time.sleep( 7176 self.parent.exponentialBackoff(tries, deadline)) 7177 continue 7178 raise plumbing.convert_error_to_porcelain(e) from e 7179 tries = 0 7180 for plumbing_item in plumbing_response.history: 7181 yield plumbing.convert_workflow_role_history_to_porcelain( 7182 plumbing_item) 7183 if plumbing_response.meta.next_cursor == '': 7184 break 7185 req.meta.cursor = plumbing_response.meta.next_cursor 7186 7187 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
7190class Workflows: 7191 ''' 7192 Workflows are the collection of rules that define the resources to which access can be requested, 7193 the users that can request that access, and the mechanism for approving those requests which can either 7194 be automatic approval or a set of users authorized to approve the requests. 7195 See `strongdm.models.Workflow`. 7196 ''' 7197 def __init__(self, channel, client): 7198 self.parent = client 7199 self.stub = WorkflowsStub(channel) 7200 7201 def create(self, workflow, timeout=None): 7202 ''' 7203 Create creates a new workflow and requires a name for the workflow. 7204 ''' 7205 deadline = None if timeout is None else time.time() + timeout 7206 req = WorkflowCreateRequest() 7207 7208 if workflow is not None: 7209 req.workflow.CopyFrom( 7210 plumbing.convert_workflow_to_plumbing(workflow)) 7211 tries = 0 7212 plumbing_response = None 7213 while True: 7214 t = None if deadline is None else deadline - time.time() 7215 try: 7216 plumbing_response = self.stub.Create( 7217 req, 7218 metadata=self.parent.get_metadata('Workflows.Create', req), 7219 timeout=t) 7220 except Exception as e: 7221 if self.parent.shouldRetry(tries, e, deadline): 7222 tries += 1 7223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7224 continue 7225 raise plumbing.convert_error_to_porcelain(e) from e 7226 break 7227 7228 resp = models.WorkflowCreateResponse() 7229 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7230 plumbing_response.rate_limit) 7231 resp.workflow = plumbing.convert_workflow_to_porcelain( 7232 plumbing_response.workflow) 7233 return resp 7234 7235 def get(self, id, timeout=None): 7236 ''' 7237 Get reads one workflow by ID. 7238 ''' 7239 deadline = None if timeout is None else time.time() + timeout 7240 req = WorkflowGetRequest() 7241 if self.parent.snapshot_datetime is not None: 7242 req.meta.CopyFrom(GetRequestMetadata()) 7243 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7244 7245 req.id = (id) 7246 tries = 0 7247 plumbing_response = None 7248 while True: 7249 t = None if deadline is None else deadline - time.time() 7250 try: 7251 plumbing_response = self.stub.Get( 7252 req, 7253 metadata=self.parent.get_metadata('Workflows.Get', req), 7254 timeout=t) 7255 except Exception as e: 7256 if self.parent.shouldRetry(tries, e, deadline): 7257 tries += 1 7258 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7259 continue 7260 raise plumbing.convert_error_to_porcelain(e) from e 7261 break 7262 7263 resp = models.WorkflowGetResponse() 7264 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7265 plumbing_response.meta) 7266 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7267 plumbing_response.rate_limit) 7268 resp.workflow = plumbing.convert_workflow_to_porcelain( 7269 plumbing_response.workflow) 7270 return resp 7271 7272 def delete(self, id, timeout=None): 7273 ''' 7274 Delete deletes an existing workflow. 7275 ''' 7276 deadline = None if timeout is None else time.time() + timeout 7277 req = WorkflowDeleteRequest() 7278 7279 req.id = (id) 7280 tries = 0 7281 plumbing_response = None 7282 while True: 7283 t = None if deadline is None else deadline - time.time() 7284 try: 7285 plumbing_response = self.stub.Delete( 7286 req, 7287 metadata=self.parent.get_metadata('Workflows.Delete', req), 7288 timeout=t) 7289 except Exception as e: 7290 if self.parent.shouldRetry(tries, e, deadline): 7291 tries += 1 7292 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7293 continue 7294 raise plumbing.convert_error_to_porcelain(e) from e 7295 break 7296 7297 resp = models.WorkflowDeleteResponse() 7298 resp.id = (plumbing_response.id) 7299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7300 plumbing_response.rate_limit) 7301 return resp 7302 7303 def update(self, workflow, timeout=None): 7304 ''' 7305 Update updates an existing workflow. 7306 ''' 7307 deadline = None if timeout is None else time.time() + timeout 7308 req = WorkflowUpdateRequest() 7309 7310 if workflow is not None: 7311 req.workflow.CopyFrom( 7312 plumbing.convert_workflow_to_plumbing(workflow)) 7313 tries = 0 7314 plumbing_response = None 7315 while True: 7316 t = None if deadline is None else deadline - time.time() 7317 try: 7318 plumbing_response = self.stub.Update( 7319 req, 7320 metadata=self.parent.get_metadata('Workflows.Update', req), 7321 timeout=t) 7322 except Exception as e: 7323 if self.parent.shouldRetry(tries, e, deadline): 7324 tries += 1 7325 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7326 continue 7327 raise plumbing.convert_error_to_porcelain(e) from e 7328 break 7329 7330 resp = models.WorkflowUpdateResponse() 7331 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7332 plumbing_response.rate_limit) 7333 resp.workflow = plumbing.convert_workflow_to_porcelain( 7334 plumbing_response.workflow) 7335 return resp 7336 7337 def list(self, filter, *args, timeout=None): 7338 ''' 7339 Lists existing workflows. 7340 ''' 7341 deadline = None if timeout is None else time.time() + timeout 7342 req = WorkflowListRequest() 7343 req.meta.CopyFrom(ListRequestMetadata()) 7344 if self.parent.page_limit > 0: 7345 req.meta.limit = self.parent.page_limit 7346 if self.parent.snapshot_datetime is not None: 7347 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7348 7349 req.filter = plumbing.quote_filter_args(filter, *args) 7350 7351 def generator(svc, req): 7352 tries = 0 7353 while True: 7354 t = None if deadline is None else deadline - time.time() 7355 try: 7356 plumbing_response = svc.stub.List( 7357 req, 7358 metadata=svc.parent.get_metadata( 7359 'Workflows.List', req), 7360 timeout=t) 7361 except Exception as e: 7362 if self.parent.shouldRetry(tries, e, deadline): 7363 tries += 1 7364 time.sleep( 7365 self.parent.exponentialBackoff(tries, deadline)) 7366 continue 7367 raise plumbing.convert_error_to_porcelain(e) from e 7368 tries = 0 7369 for plumbing_item in plumbing_response.workflows: 7370 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7371 if plumbing_response.meta.next_cursor == '': 7372 break 7373 req.meta.cursor = plumbing_response.meta.next_cursor 7374 7375 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)
7201 def create(self, workflow, timeout=None): 7202 ''' 7203 Create creates a new workflow and requires a name for the workflow. 7204 ''' 7205 deadline = None if timeout is None else time.time() + timeout 7206 req = WorkflowCreateRequest() 7207 7208 if workflow is not None: 7209 req.workflow.CopyFrom( 7210 plumbing.convert_workflow_to_plumbing(workflow)) 7211 tries = 0 7212 plumbing_response = None 7213 while True: 7214 t = None if deadline is None else deadline - time.time() 7215 try: 7216 plumbing_response = self.stub.Create( 7217 req, 7218 metadata=self.parent.get_metadata('Workflows.Create', req), 7219 timeout=t) 7220 except Exception as e: 7221 if self.parent.shouldRetry(tries, e, deadline): 7222 tries += 1 7223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7224 continue 7225 raise plumbing.convert_error_to_porcelain(e) from e 7226 break 7227 7228 resp = models.WorkflowCreateResponse() 7229 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7230 plumbing_response.rate_limit) 7231 resp.workflow = plumbing.convert_workflow_to_porcelain( 7232 plumbing_response.workflow) 7233 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
7235 def get(self, id, timeout=None): 7236 ''' 7237 Get reads one workflow by ID. 7238 ''' 7239 deadline = None if timeout is None else time.time() + timeout 7240 req = WorkflowGetRequest() 7241 if self.parent.snapshot_datetime is not None: 7242 req.meta.CopyFrom(GetRequestMetadata()) 7243 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7244 7245 req.id = (id) 7246 tries = 0 7247 plumbing_response = None 7248 while True: 7249 t = None if deadline is None else deadline - time.time() 7250 try: 7251 plumbing_response = self.stub.Get( 7252 req, 7253 metadata=self.parent.get_metadata('Workflows.Get', req), 7254 timeout=t) 7255 except Exception as e: 7256 if self.parent.shouldRetry(tries, e, deadline): 7257 tries += 1 7258 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7259 continue 7260 raise plumbing.convert_error_to_porcelain(e) from e 7261 break 7262 7263 resp = models.WorkflowGetResponse() 7264 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7265 plumbing_response.meta) 7266 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7267 plumbing_response.rate_limit) 7268 resp.workflow = plumbing.convert_workflow_to_porcelain( 7269 plumbing_response.workflow) 7270 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
7272 def delete(self, id, timeout=None): 7273 ''' 7274 Delete deletes an existing workflow. 7275 ''' 7276 deadline = None if timeout is None else time.time() + timeout 7277 req = WorkflowDeleteRequest() 7278 7279 req.id = (id) 7280 tries = 0 7281 plumbing_response = None 7282 while True: 7283 t = None if deadline is None else deadline - time.time() 7284 try: 7285 plumbing_response = self.stub.Delete( 7286 req, 7287 metadata=self.parent.get_metadata('Workflows.Delete', req), 7288 timeout=t) 7289 except Exception as e: 7290 if self.parent.shouldRetry(tries, e, deadline): 7291 tries += 1 7292 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7293 continue 7294 raise plumbing.convert_error_to_porcelain(e) from e 7295 break 7296 7297 resp = models.WorkflowDeleteResponse() 7298 resp.id = (plumbing_response.id) 7299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7300 plumbing_response.rate_limit) 7301 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
7303 def update(self, workflow, timeout=None): 7304 ''' 7305 Update updates an existing workflow. 7306 ''' 7307 deadline = None if timeout is None else time.time() + timeout 7308 req = WorkflowUpdateRequest() 7309 7310 if workflow is not None: 7311 req.workflow.CopyFrom( 7312 plumbing.convert_workflow_to_plumbing(workflow)) 7313 tries = 0 7314 plumbing_response = None 7315 while True: 7316 t = None if deadline is None else deadline - time.time() 7317 try: 7318 plumbing_response = self.stub.Update( 7319 req, 7320 metadata=self.parent.get_metadata('Workflows.Update', req), 7321 timeout=t) 7322 except Exception as e: 7323 if self.parent.shouldRetry(tries, e, deadline): 7324 tries += 1 7325 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7326 continue 7327 raise plumbing.convert_error_to_porcelain(e) from e 7328 break 7329 7330 resp = models.WorkflowUpdateResponse() 7331 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7332 plumbing_response.rate_limit) 7333 resp.workflow = plumbing.convert_workflow_to_porcelain( 7334 plumbing_response.workflow) 7335 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
7337 def list(self, filter, *args, timeout=None): 7338 ''' 7339 Lists existing workflows. 7340 ''' 7341 deadline = None if timeout is None else time.time() + timeout 7342 req = WorkflowListRequest() 7343 req.meta.CopyFrom(ListRequestMetadata()) 7344 if self.parent.page_limit > 0: 7345 req.meta.limit = self.parent.page_limit 7346 if self.parent.snapshot_datetime is not None: 7347 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7348 7349 req.filter = plumbing.quote_filter_args(filter, *args) 7350 7351 def generator(svc, req): 7352 tries = 0 7353 while True: 7354 t = None if deadline is None else deadline - time.time() 7355 try: 7356 plumbing_response = svc.stub.List( 7357 req, 7358 metadata=svc.parent.get_metadata( 7359 'Workflows.List', req), 7360 timeout=t) 7361 except Exception as e: 7362 if self.parent.shouldRetry(tries, e, deadline): 7363 tries += 1 7364 time.sleep( 7365 self.parent.exponentialBackoff(tries, deadline)) 7366 continue 7367 raise plumbing.convert_error_to_porcelain(e) from e 7368 tries = 0 7369 for plumbing_item in plumbing_response.workflows: 7370 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7371 if plumbing_response.meta.next_cursor == '': 7372 break 7373 req.meta.cursor = plumbing_response.meta.next_cursor 7374 7375 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
7378class SnapshotWorkflows: 7379 ''' 7380 SnapshotWorkflows exposes the read only methods of the Workflows 7381 service for historical queries. 7382 ''' 7383 def __init__(self, workflows): 7384 self.workflows = workflows 7385 7386 def get(self, id, timeout=None): 7387 ''' 7388 Get reads one workflow by ID. 7389 ''' 7390 return self.workflows.get(id, timeout=timeout) 7391 7392 def list(self, filter, *args, timeout=None): 7393 ''' 7394 Lists existing workflows. 7395 ''' 7396 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
7399class WorkflowsHistory: 7400 ''' 7401 WorkflowsHistory provides records of all changes to the state of a Workflow. 7402 See `strongdm.models.WorkflowHistory`. 7403 ''' 7404 def __init__(self, channel, client): 7405 self.parent = client 7406 self.stub = WorkflowsHistoryStub(channel) 7407 7408 def list(self, filter, *args, timeout=None): 7409 ''' 7410 List gets a list of WorkflowHistory records matching a given set of criteria. 7411 ''' 7412 deadline = None if timeout is None else time.time() + timeout 7413 req = WorkflowHistoryListRequest() 7414 req.meta.CopyFrom(ListRequestMetadata()) 7415 if self.parent.page_limit > 0: 7416 req.meta.limit = self.parent.page_limit 7417 if self.parent.snapshot_datetime is not None: 7418 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7419 7420 req.filter = plumbing.quote_filter_args(filter, *args) 7421 7422 def generator(svc, req): 7423 tries = 0 7424 while True: 7425 t = None if deadline is None else deadline - time.time() 7426 try: 7427 plumbing_response = svc.stub.List( 7428 req, 7429 metadata=svc.parent.get_metadata( 7430 'WorkflowsHistory.List', req), 7431 timeout=t) 7432 except Exception as e: 7433 if self.parent.shouldRetry(tries, e, deadline): 7434 tries += 1 7435 time.sleep( 7436 self.parent.exponentialBackoff(tries, deadline)) 7437 continue 7438 raise plumbing.convert_error_to_porcelain(e) from e 7439 tries = 0 7440 for plumbing_item in plumbing_response.history: 7441 yield plumbing.convert_workflow_history_to_porcelain( 7442 plumbing_item) 7443 if plumbing_response.meta.next_cursor == '': 7444 break 7445 req.meta.cursor = plumbing_response.meta.next_cursor 7446 7447 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)
7408 def list(self, filter, *args, timeout=None): 7409 ''' 7410 List gets a list of WorkflowHistory records matching a given set of criteria. 7411 ''' 7412 deadline = None if timeout is None else time.time() + timeout 7413 req = WorkflowHistoryListRequest() 7414 req.meta.CopyFrom(ListRequestMetadata()) 7415 if self.parent.page_limit > 0: 7416 req.meta.limit = self.parent.page_limit 7417 if self.parent.snapshot_datetime is not None: 7418 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7419 7420 req.filter = plumbing.quote_filter_args(filter, *args) 7421 7422 def generator(svc, req): 7423 tries = 0 7424 while True: 7425 t = None if deadline is None else deadline - time.time() 7426 try: 7427 plumbing_response = svc.stub.List( 7428 req, 7429 metadata=svc.parent.get_metadata( 7430 'WorkflowsHistory.List', req), 7431 timeout=t) 7432 except Exception as e: 7433 if self.parent.shouldRetry(tries, e, deadline): 7434 tries += 1 7435 time.sleep( 7436 self.parent.exponentialBackoff(tries, deadline)) 7437 continue 7438 raise plumbing.convert_error_to_porcelain(e) from e 7439 tries = 0 7440 for plumbing_item in plumbing_response.history: 7441 yield plumbing.convert_workflow_history_to_porcelain( 7442 plumbing_item) 7443 if plumbing_response.meta.next_cursor == '': 7444 break 7445 req.meta.cursor = plumbing_response.meta.next_cursor 7446 7447 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.