strongdm.svc
1# Copyright 2020 StrongDM Inc 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# 15 16# Code generated by protogen. DO NOT EDIT. 17 18import grpc 19from . import plumbing 20from . import models 21from .options_pb2 import * 22from .options_pb2_grpc import * 23from .spec_pb2 import * 24from .spec_pb2_grpc import * 25from .tags_pb2 import * 26from .tags_pb2_grpc import * 27from .access_requests_pb2 import * 28from .access_requests_pb2_grpc import * 29from .access_request_events_history_pb2 import * 30from .access_request_events_history_pb2_grpc import * 31from .access_requests_history_pb2 import * 32from .access_requests_history_pb2_grpc import * 33from .drivers_pb2 import * 34from .drivers_pb2_grpc import * 35from .account_attachments_pb2 import * 36from .account_attachments_pb2_grpc import * 37from .account_attachments_history_pb2 import * 38from .account_attachments_history_pb2_grpc import * 39from .account_grants_pb2 import * 40from .account_grants_pb2_grpc import * 41from .account_grants_history_pb2 import * 42from .account_grants_history_pb2_grpc import * 43from .account_permissions_pb2 import * 44from .account_permissions_pb2_grpc import * 45from .account_resources_pb2 import * 46from .account_resources_pb2_grpc import * 47from .account_resources_history_pb2 import * 48from .account_resources_history_pb2_grpc import * 49from .accounts_pb2 import * 50from .accounts_pb2_grpc import * 51from .accounts_groups_pb2 import * 52from .accounts_groups_pb2_grpc import * 53from .accounts_groups_history_pb2 import * 54from .accounts_groups_history_pb2_grpc import * 55from .accounts_history_pb2 import * 56from .accounts_history_pb2_grpc import * 57from .activities_pb2 import * 58from .activities_pb2_grpc import * 59from .approval_workflow_approvers_pb2 import * 60from .approval_workflow_approvers_pb2_grpc import * 61from .approval_workflow_approvers_history_pb2 import * 62from .approval_workflow_approvers_history_pb2_grpc import * 63from .approval_workflow_steps_pb2 import * 64from .approval_workflow_steps_pb2_grpc import * 65from .approval_workflow_steps_history_pb2 import * 66from .approval_workflow_steps_history_pb2_grpc import * 67from .approval_workflows_pb2 import * 68from .approval_workflows_pb2_grpc import * 69from .approval_workflows_history_pb2 import * 70from .approval_workflows_history_pb2_grpc import * 71from .control_panel_pb2 import * 72from .control_panel_pb2_grpc import * 73from .roles_pb2 import * 74from .roles_pb2_grpc import * 75from .groups_pb2 import * 76from .groups_pb2_grpc import * 77from .groups_history_pb2 import * 78from .groups_history_pb2_grpc import * 79from .groups_roles_pb2 import * 80from .groups_roles_pb2_grpc import * 81from .groups_roles_history_pb2 import * 82from .groups_roles_history_pb2_grpc import * 83from .health_checks_pb2 import * 84from .health_checks_pb2_grpc import * 85from .identity_aliases_pb2 import * 86from .identity_aliases_pb2_grpc import * 87from .identity_aliases_history_pb2 import * 88from .identity_aliases_history_pb2_grpc import * 89from .identity_sets_pb2 import * 90from .identity_sets_pb2_grpc import * 91from .identity_sets_history_pb2 import * 92from .identity_sets_history_pb2_grpc import * 93from .managed_secrets_pb2 import * 94from .managed_secrets_pb2_grpc import * 95from .nodes_pb2 import * 96from .nodes_pb2_grpc import * 97from .nodes_history_pb2 import * 98from .nodes_history_pb2_grpc import * 99from .organization_history_pb2 import * 100from .organization_history_pb2_grpc import * 101from .peering_group_nodes_pb2 import * 102from .peering_group_nodes_pb2_grpc import * 103from .peering_group_peers_pb2 import * 104from .peering_group_peers_pb2_grpc import * 105from .peering_group_resources_pb2 import * 106from .peering_group_resources_pb2_grpc import * 107from .peering_groups_pb2 import * 108from .peering_groups_pb2_grpc import * 109from .policies_pb2 import * 110from .policies_pb2_grpc import * 111from .policies_history_pb2 import * 112from .policies_history_pb2_grpc import * 113from .proxy_cluster_keys_pb2 import * 114from .proxy_cluster_keys_pb2_grpc import * 115from .queries_pb2 import * 116from .queries_pb2_grpc import * 117from .remote_identities_pb2 import * 118from .remote_identities_pb2_grpc import * 119from .remote_identities_history_pb2 import * 120from .remote_identities_history_pb2_grpc import * 121from .remote_identity_groups_pb2 import * 122from .remote_identity_groups_pb2_grpc import * 123from .remote_identity_groups_history_pb2 import * 124from .remote_identity_groups_history_pb2_grpc import * 125from .replays_pb2 import * 126from .replays_pb2_grpc import * 127from .resources_pb2 import * 128from .resources_pb2_grpc import * 129from .resources_history_pb2 import * 130from .resources_history_pb2_grpc import * 131from .role_resources_pb2 import * 132from .role_resources_pb2_grpc import * 133from .role_resources_history_pb2 import * 134from .role_resources_history_pb2_grpc import * 135from .roles_history_pb2 import * 136from .roles_history_pb2_grpc import * 137from .secret_engine_policy_pb2 import * 138from .secret_engine_policy_pb2_grpc import * 139from .secret_engine_types_pb2 import * 140from .secret_engine_types_pb2_grpc import * 141from .secret_store_types_pb2 import * 142from .secret_store_types_pb2_grpc import * 143from .secret_stores_pb2 import * 144from .secret_stores_pb2_grpc import * 145from .secret_engines_pb2 import * 146from .secret_engines_pb2_grpc import * 147from .secret_store_healths_pb2 import * 148from .secret_store_healths_pb2_grpc import * 149from .secret_stores_history_pb2 import * 150from .secret_stores_history_pb2_grpc import * 151from .workflow_approvers_pb2 import * 152from .workflow_approvers_pb2_grpc import * 153from .workflow_approvers_history_pb2 import * 154from .workflow_approvers_history_pb2_grpc import * 155from .workflow_roles_pb2 import * 156from .workflow_roles_pb2_grpc import * 157from .workflow_roles_history_pb2 import * 158from .workflow_roles_history_pb2_grpc import * 159from .workflows_pb2 import * 160from .workflows_pb2_grpc import * 161from .workflows_history_pb2 import * 162from .workflows_history_pb2_grpc import * 163import warnings 164import functools 165import time 166 167 168def deprecated(func): 169 """This is a decorator which can be used to mark functions 170 as deprecated. It will result in a warning being emitted 171 when the function is used.""" 172 @functools.wraps(func) 173 def new_func(*args, **kwargs): 174 warnings.warn("Call to deprecated function {}.".format(func.__name__), 175 category=DeprecationWarning, 176 stacklevel=2) 177 return func(*args, **kwargs) 178 179 return new_func 180 181 182class AccessRequests: 183 ''' 184 AccessRequests are requests for access to a resource that may match a Workflow. 185 See `strongdm.models.AccessRequest`. 186 ''' 187 def __init__(self, channel, client): 188 self.parent = client 189 self.stub = AccessRequestsStub(channel) 190 191 def list(self, filter, *args, timeout=None): 192 ''' 193 Lists existing access requests. 194 ''' 195 deadline = None if timeout is None else time.time() + timeout 196 req = AccessRequestListRequest() 197 req.meta.CopyFrom(ListRequestMetadata()) 198 if self.parent.page_limit > 0: 199 req.meta.limit = self.parent.page_limit 200 if self.parent.snapshot_datetime is not None: 201 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 202 203 req.filter = plumbing.quote_filter_args(filter, *args) 204 205 def generator(svc, req): 206 tries = 0 207 while True: 208 t = None if deadline is None else deadline - time.time() 209 try: 210 plumbing_response = svc.stub.List( 211 req, 212 metadata=svc.parent.get_metadata( 213 'AccessRequests.List', req), 214 timeout=t) 215 except Exception as e: 216 if self.parent.shouldRetry(tries, e, deadline): 217 tries += 1 218 time.sleep( 219 self.parent.exponentialBackoff(tries, deadline)) 220 continue 221 raise plumbing.convert_error_to_porcelain(e) from e 222 tries = 0 223 for plumbing_item in plumbing_response.access_requests: 224 yield plumbing.convert_access_request_to_porcelain( 225 plumbing_item) 226 if plumbing_response.meta.next_cursor == '': 227 break 228 req.meta.cursor = plumbing_response.meta.next_cursor 229 230 return generator(self, req) 231 232 233class SnapshotAccessRequests: 234 ''' 235 SnapshotAccessRequests exposes the read only methods of the AccessRequests 236 service for historical queries. 237 ''' 238 def __init__(self, access_requests): 239 self.access_requests = access_requests 240 241 def list(self, filter, *args, timeout=None): 242 ''' 243 Lists existing access requests. 244 ''' 245 return self.access_requests.list(filter, *args, timeout=timeout) 246 247 248class AccessRequestEventsHistory: 249 ''' 250 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 251 See `strongdm.models.AccessRequestEventHistory`. 252 ''' 253 def __init__(self, channel, client): 254 self.parent = client 255 self.stub = AccessRequestEventsHistoryStub(channel) 256 257 def list(self, filter, *args, timeout=None): 258 ''' 259 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 260 ''' 261 deadline = None if timeout is None else time.time() + timeout 262 req = AccessRequestEventHistoryListRequest() 263 req.meta.CopyFrom(ListRequestMetadata()) 264 if self.parent.page_limit > 0: 265 req.meta.limit = self.parent.page_limit 266 if self.parent.snapshot_datetime is not None: 267 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 268 269 req.filter = plumbing.quote_filter_args(filter, *args) 270 271 def generator(svc, req): 272 tries = 0 273 while True: 274 t = None if deadline is None else deadline - time.time() 275 try: 276 plumbing_response = svc.stub.List( 277 req, 278 metadata=svc.parent.get_metadata( 279 'AccessRequestEventsHistory.List', req), 280 timeout=t) 281 except Exception as e: 282 if self.parent.shouldRetry(tries, e, deadline): 283 tries += 1 284 time.sleep( 285 self.parent.exponentialBackoff(tries, deadline)) 286 continue 287 raise plumbing.convert_error_to_porcelain(e) from e 288 tries = 0 289 for plumbing_item in plumbing_response.history: 290 yield plumbing.convert_access_request_event_history_to_porcelain( 291 plumbing_item) 292 if plumbing_response.meta.next_cursor == '': 293 break 294 req.meta.cursor = plumbing_response.meta.next_cursor 295 296 return generator(self, req) 297 298 299class AccessRequestsHistory: 300 ''' 301 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 302 See `strongdm.models.AccessRequestHistory`. 303 ''' 304 def __init__(self, channel, client): 305 self.parent = client 306 self.stub = AccessRequestsHistoryStub(channel) 307 308 def list(self, filter, *args, timeout=None): 309 ''' 310 List gets a list of AccessRequestHistory records matching a given set of criteria. 311 ''' 312 deadline = None if timeout is None else time.time() + timeout 313 req = AccessRequestHistoryListRequest() 314 req.meta.CopyFrom(ListRequestMetadata()) 315 if self.parent.page_limit > 0: 316 req.meta.limit = self.parent.page_limit 317 if self.parent.snapshot_datetime is not None: 318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 319 320 req.filter = plumbing.quote_filter_args(filter, *args) 321 322 def generator(svc, req): 323 tries = 0 324 while True: 325 t = None if deadline is None else deadline - time.time() 326 try: 327 plumbing_response = svc.stub.List( 328 req, 329 metadata=svc.parent.get_metadata( 330 'AccessRequestsHistory.List', req), 331 timeout=t) 332 except Exception as e: 333 if self.parent.shouldRetry(tries, e, deadline): 334 tries += 1 335 time.sleep( 336 self.parent.exponentialBackoff(tries, deadline)) 337 continue 338 raise plumbing.convert_error_to_porcelain(e) from e 339 tries = 0 340 for plumbing_item in plumbing_response.history: 341 yield plumbing.convert_access_request_history_to_porcelain( 342 plumbing_item) 343 if plumbing_response.meta.next_cursor == '': 344 break 345 req.meta.cursor = plumbing_response.meta.next_cursor 346 347 return generator(self, req) 348 349 350class AccountAttachments: 351 ''' 352 AccountAttachments assign an account to a role. 353 See `strongdm.models.AccountAttachment`. 354 ''' 355 def __init__(self, channel, client): 356 self.parent = client 357 self.stub = AccountAttachmentsStub(channel) 358 359 def create(self, account_attachment, timeout=None): 360 ''' 361 Create registers a new AccountAttachment. 362 ''' 363 deadline = None if timeout is None else time.time() + timeout 364 req = AccountAttachmentCreateRequest() 365 366 if account_attachment is not None: 367 req.account_attachment.CopyFrom( 368 plumbing.convert_account_attachment_to_plumbing( 369 account_attachment)) 370 tries = 0 371 plumbing_response = None 372 while True: 373 t = None if deadline is None else deadline - time.time() 374 try: 375 plumbing_response = self.stub.Create( 376 req, 377 metadata=self.parent.get_metadata( 378 'AccountAttachments.Create', req), 379 timeout=t) 380 except Exception as e: 381 if self.parent.shouldRetry(tries, e, deadline): 382 tries += 1 383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 384 continue 385 raise plumbing.convert_error_to_porcelain(e) from e 386 break 387 388 resp = models.AccountAttachmentCreateResponse() 389 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 390 plumbing_response.account_attachment) 391 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 392 plumbing_response.meta) 393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 394 plumbing_response.rate_limit) 395 return resp 396 397 def get(self, id, timeout=None): 398 ''' 399 Get reads one AccountAttachment by ID. 400 ''' 401 deadline = None if timeout is None else time.time() + timeout 402 req = AccountAttachmentGetRequest() 403 if self.parent.snapshot_datetime is not None: 404 req.meta.CopyFrom(GetRequestMetadata()) 405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 406 407 req.id = (id) 408 tries = 0 409 plumbing_response = None 410 while True: 411 t = None if deadline is None else deadline - time.time() 412 try: 413 plumbing_response = self.stub.Get( 414 req, 415 metadata=self.parent.get_metadata('AccountAttachments.Get', 416 req), 417 timeout=t) 418 except Exception as e: 419 if self.parent.shouldRetry(tries, e, deadline): 420 tries += 1 421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 422 continue 423 raise plumbing.convert_error_to_porcelain(e) from e 424 break 425 426 resp = models.AccountAttachmentGetResponse() 427 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 428 plumbing_response.account_attachment) 429 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 430 plumbing_response.meta) 431 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 432 plumbing_response.rate_limit) 433 return resp 434 435 def delete(self, id, timeout=None): 436 ''' 437 Delete removes a AccountAttachment by ID. 438 ''' 439 deadline = None if timeout is None else time.time() + timeout 440 req = AccountAttachmentDeleteRequest() 441 442 req.id = (id) 443 tries = 0 444 plumbing_response = None 445 while True: 446 t = None if deadline is None else deadline - time.time() 447 try: 448 plumbing_response = self.stub.Delete( 449 req, 450 metadata=self.parent.get_metadata( 451 'AccountAttachments.Delete', req), 452 timeout=t) 453 except Exception as e: 454 if self.parent.shouldRetry(tries, e, deadline): 455 tries += 1 456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 457 continue 458 raise plumbing.convert_error_to_porcelain(e) from e 459 break 460 461 resp = models.AccountAttachmentDeleteResponse() 462 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 463 plumbing_response.meta) 464 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 465 plumbing_response.rate_limit) 466 return resp 467 468 def list(self, filter, *args, timeout=None): 469 ''' 470 List gets a list of AccountAttachments matching a given set of criteria. 471 ''' 472 deadline = None if timeout is None else time.time() + timeout 473 req = AccountAttachmentListRequest() 474 req.meta.CopyFrom(ListRequestMetadata()) 475 if self.parent.page_limit > 0: 476 req.meta.limit = self.parent.page_limit 477 if self.parent.snapshot_datetime is not None: 478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 479 480 req.filter = plumbing.quote_filter_args(filter, *args) 481 482 def generator(svc, req): 483 tries = 0 484 while True: 485 t = None if deadline is None else deadline - time.time() 486 try: 487 plumbing_response = svc.stub.List( 488 req, 489 metadata=svc.parent.get_metadata( 490 'AccountAttachments.List', req), 491 timeout=t) 492 except Exception as e: 493 if self.parent.shouldRetry(tries, e, deadline): 494 tries += 1 495 time.sleep( 496 self.parent.exponentialBackoff(tries, deadline)) 497 continue 498 raise plumbing.convert_error_to_porcelain(e) from e 499 tries = 0 500 for plumbing_item in plumbing_response.account_attachments: 501 yield plumbing.convert_account_attachment_to_porcelain( 502 plumbing_item) 503 if plumbing_response.meta.next_cursor == '': 504 break 505 req.meta.cursor = plumbing_response.meta.next_cursor 506 507 return generator(self, req) 508 509 510class SnapshotAccountAttachments: 511 ''' 512 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 513 service for historical queries. 514 ''' 515 def __init__(self, account_attachments): 516 self.account_attachments = account_attachments 517 518 def get(self, id, timeout=None): 519 ''' 520 Get reads one AccountAttachment by ID. 521 ''' 522 return self.account_attachments.get(id, timeout=timeout) 523 524 def list(self, filter, *args, timeout=None): 525 ''' 526 List gets a list of AccountAttachments matching a given set of criteria. 527 ''' 528 return self.account_attachments.list(filter, *args, timeout=timeout) 529 530 531class AccountAttachmentsHistory: 532 ''' 533 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 534 See `strongdm.models.AccountAttachmentHistory`. 535 ''' 536 def __init__(self, channel, client): 537 self.parent = client 538 self.stub = AccountAttachmentsHistoryStub(channel) 539 540 def list(self, filter, *args, timeout=None): 541 ''' 542 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 543 ''' 544 deadline = None if timeout is None else time.time() + timeout 545 req = AccountAttachmentHistoryListRequest() 546 req.meta.CopyFrom(ListRequestMetadata()) 547 if self.parent.page_limit > 0: 548 req.meta.limit = self.parent.page_limit 549 if self.parent.snapshot_datetime is not None: 550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 551 552 req.filter = plumbing.quote_filter_args(filter, *args) 553 554 def generator(svc, req): 555 tries = 0 556 while True: 557 t = None if deadline is None else deadline - time.time() 558 try: 559 plumbing_response = svc.stub.List( 560 req, 561 metadata=svc.parent.get_metadata( 562 'AccountAttachmentsHistory.List', req), 563 timeout=t) 564 except Exception as e: 565 if self.parent.shouldRetry(tries, e, deadline): 566 tries += 1 567 time.sleep( 568 self.parent.exponentialBackoff(tries, deadline)) 569 continue 570 raise plumbing.convert_error_to_porcelain(e) from e 571 tries = 0 572 for plumbing_item in plumbing_response.history: 573 yield plumbing.convert_account_attachment_history_to_porcelain( 574 plumbing_item) 575 if plumbing_response.meta.next_cursor == '': 576 break 577 req.meta.cursor = plumbing_response.meta.next_cursor 578 579 return generator(self, req) 580 581 582class AccountGrants: 583 ''' 584 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 585 See `strongdm.models.AccountGrant`. 586 ''' 587 def __init__(self, channel, client): 588 self.parent = client 589 self.stub = AccountGrantsStub(channel) 590 591 def create(self, account_grant, timeout=None): 592 ''' 593 Create registers a new AccountGrant. 594 ''' 595 deadline = None if timeout is None else time.time() + timeout 596 req = AccountGrantCreateRequest() 597 598 if account_grant is not None: 599 req.account_grant.CopyFrom( 600 plumbing.convert_account_grant_to_plumbing(account_grant)) 601 tries = 0 602 plumbing_response = None 603 while True: 604 t = None if deadline is None else deadline - time.time() 605 try: 606 plumbing_response = self.stub.Create( 607 req, 608 metadata=self.parent.get_metadata('AccountGrants.Create', 609 req), 610 timeout=t) 611 except Exception as e: 612 if self.parent.shouldRetry(tries, e, deadline): 613 tries += 1 614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 615 continue 616 raise plumbing.convert_error_to_porcelain(e) from e 617 break 618 619 resp = models.AccountGrantCreateResponse() 620 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 621 plumbing_response.account_grant) 622 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 623 plumbing_response.meta) 624 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 625 plumbing_response.rate_limit) 626 return resp 627 628 def get(self, id, timeout=None): 629 ''' 630 Get reads one AccountGrant by ID. 631 ''' 632 deadline = None if timeout is None else time.time() + timeout 633 req = AccountGrantGetRequest() 634 if self.parent.snapshot_datetime is not None: 635 req.meta.CopyFrom(GetRequestMetadata()) 636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 637 638 req.id = (id) 639 tries = 0 640 plumbing_response = None 641 while True: 642 t = None if deadline is None else deadline - time.time() 643 try: 644 plumbing_response = self.stub.Get( 645 req, 646 metadata=self.parent.get_metadata('AccountGrants.Get', 647 req), 648 timeout=t) 649 except Exception as e: 650 if self.parent.shouldRetry(tries, e, deadline): 651 tries += 1 652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 653 continue 654 raise plumbing.convert_error_to_porcelain(e) from e 655 break 656 657 resp = models.AccountGrantGetResponse() 658 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 659 plumbing_response.account_grant) 660 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 661 plumbing_response.meta) 662 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 663 plumbing_response.rate_limit) 664 return resp 665 666 def delete(self, id, timeout=None): 667 ''' 668 Delete removes a AccountGrant by ID. 669 ''' 670 deadline = None if timeout is None else time.time() + timeout 671 req = AccountGrantDeleteRequest() 672 673 req.id = (id) 674 tries = 0 675 plumbing_response = None 676 while True: 677 t = None if deadline is None else deadline - time.time() 678 try: 679 plumbing_response = self.stub.Delete( 680 req, 681 metadata=self.parent.get_metadata('AccountGrants.Delete', 682 req), 683 timeout=t) 684 except Exception as e: 685 if self.parent.shouldRetry(tries, e, deadline): 686 tries += 1 687 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 688 continue 689 raise plumbing.convert_error_to_porcelain(e) from e 690 break 691 692 resp = models.AccountGrantDeleteResponse() 693 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 694 plumbing_response.meta) 695 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 696 plumbing_response.rate_limit) 697 return resp 698 699 def list(self, filter, *args, timeout=None): 700 ''' 701 List gets a list of AccountGrants matching a given set of criteria. 702 ''' 703 deadline = None if timeout is None else time.time() + timeout 704 req = AccountGrantListRequest() 705 req.meta.CopyFrom(ListRequestMetadata()) 706 if self.parent.page_limit > 0: 707 req.meta.limit = self.parent.page_limit 708 if self.parent.snapshot_datetime is not None: 709 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 710 711 req.filter = plumbing.quote_filter_args(filter, *args) 712 713 def generator(svc, req): 714 tries = 0 715 while True: 716 t = None if deadline is None else deadline - time.time() 717 try: 718 plumbing_response = svc.stub.List( 719 req, 720 metadata=svc.parent.get_metadata( 721 'AccountGrants.List', req), 722 timeout=t) 723 except Exception as e: 724 if self.parent.shouldRetry(tries, e, deadline): 725 tries += 1 726 time.sleep( 727 self.parent.exponentialBackoff(tries, deadline)) 728 continue 729 raise plumbing.convert_error_to_porcelain(e) from e 730 tries = 0 731 for plumbing_item in plumbing_response.account_grants: 732 yield plumbing.convert_account_grant_to_porcelain( 733 plumbing_item) 734 if plumbing_response.meta.next_cursor == '': 735 break 736 req.meta.cursor = plumbing_response.meta.next_cursor 737 738 return generator(self, req) 739 740 741class SnapshotAccountGrants: 742 ''' 743 SnapshotAccountGrants exposes the read only methods of the AccountGrants 744 service for historical queries. 745 ''' 746 def __init__(self, account_grants): 747 self.account_grants = account_grants 748 749 def get(self, id, timeout=None): 750 ''' 751 Get reads one AccountGrant by ID. 752 ''' 753 return self.account_grants.get(id, timeout=timeout) 754 755 def list(self, filter, *args, timeout=None): 756 ''' 757 List gets a list of AccountGrants matching a given set of criteria. 758 ''' 759 return self.account_grants.list(filter, *args, timeout=timeout) 760 761 762class AccountGrantsHistory: 763 ''' 764 AccountGrantsHistory records all changes to the state of an AccountGrant. 765 See `strongdm.models.AccountGrantHistory`. 766 ''' 767 def __init__(self, channel, client): 768 self.parent = client 769 self.stub = AccountGrantsHistoryStub(channel) 770 771 def list(self, filter, *args, timeout=None): 772 ''' 773 List gets a list of AccountGrantHistory records matching a given set of criteria. 774 ''' 775 deadline = None if timeout is None else time.time() + timeout 776 req = AccountGrantHistoryListRequest() 777 req.meta.CopyFrom(ListRequestMetadata()) 778 if self.parent.page_limit > 0: 779 req.meta.limit = self.parent.page_limit 780 if self.parent.snapshot_datetime is not None: 781 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 782 783 req.filter = plumbing.quote_filter_args(filter, *args) 784 785 def generator(svc, req): 786 tries = 0 787 while True: 788 t = None if deadline is None else deadline - time.time() 789 try: 790 plumbing_response = svc.stub.List( 791 req, 792 metadata=svc.parent.get_metadata( 793 'AccountGrantsHistory.List', req), 794 timeout=t) 795 except Exception as e: 796 if self.parent.shouldRetry(tries, e, deadline): 797 tries += 1 798 time.sleep( 799 self.parent.exponentialBackoff(tries, deadline)) 800 continue 801 raise plumbing.convert_error_to_porcelain(e) from e 802 tries = 0 803 for plumbing_item in plumbing_response.history: 804 yield plumbing.convert_account_grant_history_to_porcelain( 805 plumbing_item) 806 if plumbing_response.meta.next_cursor == '': 807 break 808 req.meta.cursor = plumbing_response.meta.next_cursor 809 810 return generator(self, req) 811 812 813class AccountPermissions: 814 ''' 815 AccountPermissions records the granular permissions accounts have, allowing them to execute 816 relevant commands via StrongDM's APIs. 817 See `strongdm.models.AccountPermission`. 818 ''' 819 def __init__(self, channel, client): 820 self.parent = client 821 self.stub = AccountPermissionsStub(channel) 822 823 def list(self, filter, *args, timeout=None): 824 ''' 825 List gets a list of Permission records matching a given set of criteria. 826 ''' 827 deadline = None if timeout is None else time.time() + timeout 828 req = AccountPermissionListRequest() 829 req.meta.CopyFrom(ListRequestMetadata()) 830 if self.parent.page_limit > 0: 831 req.meta.limit = self.parent.page_limit 832 if self.parent.snapshot_datetime is not None: 833 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 834 835 req.filter = plumbing.quote_filter_args(filter, *args) 836 837 def generator(svc, req): 838 tries = 0 839 while True: 840 t = None if deadline is None else deadline - time.time() 841 try: 842 plumbing_response = svc.stub.List( 843 req, 844 metadata=svc.parent.get_metadata( 845 'AccountPermissions.List', req), 846 timeout=t) 847 except Exception as e: 848 if self.parent.shouldRetry(tries, e, deadline): 849 tries += 1 850 time.sleep( 851 self.parent.exponentialBackoff(tries, deadline)) 852 continue 853 raise plumbing.convert_error_to_porcelain(e) from e 854 tries = 0 855 for plumbing_item in plumbing_response.permissions: 856 yield plumbing.convert_account_permission_to_porcelain( 857 plumbing_item) 858 if plumbing_response.meta.next_cursor == '': 859 break 860 req.meta.cursor = plumbing_response.meta.next_cursor 861 862 return generator(self, req) 863 864 865class SnapshotAccountPermissions: 866 ''' 867 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 868 service for historical queries. 869 ''' 870 def __init__(self, account_permissions): 871 self.account_permissions = account_permissions 872 873 def list(self, filter, *args, timeout=None): 874 ''' 875 List gets a list of Permission records matching a given set of criteria. 876 ''' 877 return self.account_permissions.list(filter, *args, timeout=timeout) 878 879 880class AccountResources: 881 ''' 882 AccountResources enumerates the resources to which accounts have access. 883 The AccountResources service is read-only. 884 See `strongdm.models.AccountResource`. 885 ''' 886 def __init__(self, channel, client): 887 self.parent = client 888 self.stub = AccountResourcesStub(channel) 889 890 def list(self, filter, *args, timeout=None): 891 ''' 892 List gets a list of AccountResource records matching a given set of criteria. 893 ''' 894 deadline = None if timeout is None else time.time() + timeout 895 req = AccountResourceListRequest() 896 req.meta.CopyFrom(ListRequestMetadata()) 897 if self.parent.page_limit > 0: 898 req.meta.limit = self.parent.page_limit 899 if self.parent.snapshot_datetime is not None: 900 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 901 902 req.filter = plumbing.quote_filter_args(filter, *args) 903 904 def generator(svc, req): 905 tries = 0 906 while True: 907 t = None if deadline is None else deadline - time.time() 908 try: 909 plumbing_response = svc.stub.List( 910 req, 911 metadata=svc.parent.get_metadata( 912 'AccountResources.List', req), 913 timeout=t) 914 except Exception as e: 915 if self.parent.shouldRetry(tries, e, deadline): 916 tries += 1 917 time.sleep( 918 self.parent.exponentialBackoff(tries, deadline)) 919 continue 920 raise plumbing.convert_error_to_porcelain(e) from e 921 tries = 0 922 for plumbing_item in plumbing_response.account_resources: 923 yield plumbing.convert_account_resource_to_porcelain( 924 plumbing_item) 925 if plumbing_response.meta.next_cursor == '': 926 break 927 req.meta.cursor = plumbing_response.meta.next_cursor 928 929 return generator(self, req) 930 931 932class SnapshotAccountResources: 933 ''' 934 SnapshotAccountResources exposes the read only methods of the AccountResources 935 service for historical queries. 936 ''' 937 def __init__(self, account_resources): 938 self.account_resources = account_resources 939 940 def list(self, filter, *args, timeout=None): 941 ''' 942 List gets a list of AccountResource records matching a given set of criteria. 943 ''' 944 return self.account_resources.list(filter, *args, timeout=timeout) 945 946 947class AccountResourcesHistory: 948 ''' 949 AccountResourcesHistory records all changes to the state of a AccountResource. 950 See `strongdm.models.AccountResourceHistory`. 951 ''' 952 def __init__(self, channel, client): 953 self.parent = client 954 self.stub = AccountResourcesHistoryStub(channel) 955 956 def list(self, filter, *args, timeout=None): 957 ''' 958 List gets a list of AccountResourceHistory records matching a given set of criteria. 959 ''' 960 deadline = None if timeout is None else time.time() + timeout 961 req = AccountResourceHistoryListRequest() 962 req.meta.CopyFrom(ListRequestMetadata()) 963 if self.parent.page_limit > 0: 964 req.meta.limit = self.parent.page_limit 965 if self.parent.snapshot_datetime is not None: 966 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 967 968 req.filter = plumbing.quote_filter_args(filter, *args) 969 970 def generator(svc, req): 971 tries = 0 972 while True: 973 t = None if deadline is None else deadline - time.time() 974 try: 975 plumbing_response = svc.stub.List( 976 req, 977 metadata=svc.parent.get_metadata( 978 'AccountResourcesHistory.List', req), 979 timeout=t) 980 except Exception as e: 981 if self.parent.shouldRetry(tries, e, deadline): 982 tries += 1 983 time.sleep( 984 self.parent.exponentialBackoff(tries, deadline)) 985 continue 986 raise plumbing.convert_error_to_porcelain(e) from e 987 tries = 0 988 for plumbing_item in plumbing_response.history: 989 yield plumbing.convert_account_resource_history_to_porcelain( 990 plumbing_item) 991 if plumbing_response.meta.next_cursor == '': 992 break 993 req.meta.cursor = plumbing_response.meta.next_cursor 994 995 return generator(self, req) 996 997 998class Accounts: 999 ''' 1000 Accounts are users that have access to strongDM. There are two types of accounts: 1001 1. **Users:** humans who are authenticated through username and password or SSO. 1002 2. **Service Accounts:** machines that are authenticated using a service token. 1003 3. **Tokens** are access keys with permissions that can be used for authentication. 1004 See: 1005 `strongdm.models.Service` 1006 `strongdm.models.Token` 1007 `strongdm.models.User` 1008 ''' 1009 def __init__(self, channel, client): 1010 self.parent = client 1011 self.stub = AccountsStub(channel) 1012 1013 def create(self, account, timeout=None): 1014 ''' 1015 Create registers a new Account. 1016 ''' 1017 deadline = None if timeout is None else time.time() + timeout 1018 req = AccountCreateRequest() 1019 1020 if account is not None: 1021 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1022 tries = 0 1023 plumbing_response = None 1024 while True: 1025 t = None if deadline is None else deadline - time.time() 1026 try: 1027 plumbing_response = self.stub.Create( 1028 req, 1029 metadata=self.parent.get_metadata('Accounts.Create', req), 1030 timeout=t) 1031 except Exception as e: 1032 if self.parent.shouldRetry(tries, e, deadline): 1033 tries += 1 1034 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1035 continue 1036 raise plumbing.convert_error_to_porcelain(e) from e 1037 break 1038 1039 resp = models.AccountCreateResponse() 1040 resp.access_key = (plumbing_response.access_key) 1041 resp.account = plumbing.convert_account_to_porcelain( 1042 plumbing_response.account) 1043 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1044 plumbing_response.meta) 1045 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1046 plumbing_response.rate_limit) 1047 resp.secret_key = (plumbing_response.secret_key) 1048 resp.token = (plumbing_response.token) 1049 return resp 1050 1051 def get(self, id, timeout=None): 1052 ''' 1053 Get reads one Account by ID. 1054 ''' 1055 deadline = None if timeout is None else time.time() + timeout 1056 req = AccountGetRequest() 1057 if self.parent.snapshot_datetime is not None: 1058 req.meta.CopyFrom(GetRequestMetadata()) 1059 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1060 1061 req.id = (id) 1062 tries = 0 1063 plumbing_response = None 1064 while True: 1065 t = None if deadline is None else deadline - time.time() 1066 try: 1067 plumbing_response = self.stub.Get( 1068 req, 1069 metadata=self.parent.get_metadata('Accounts.Get', req), 1070 timeout=t) 1071 except Exception as e: 1072 if self.parent.shouldRetry(tries, e, deadline): 1073 tries += 1 1074 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1075 continue 1076 raise plumbing.convert_error_to_porcelain(e) from e 1077 break 1078 1079 resp = models.AccountGetResponse() 1080 resp.account = plumbing.convert_account_to_porcelain( 1081 plumbing_response.account) 1082 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1083 plumbing_response.meta) 1084 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1085 plumbing_response.rate_limit) 1086 return resp 1087 1088 def update(self, account, timeout=None): 1089 ''' 1090 Update replaces all the fields of an Account by ID. 1091 ''' 1092 deadline = None if timeout is None else time.time() + timeout 1093 req = AccountUpdateRequest() 1094 1095 if account is not None: 1096 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1097 tries = 0 1098 plumbing_response = None 1099 while True: 1100 t = None if deadline is None else deadline - time.time() 1101 try: 1102 plumbing_response = self.stub.Update( 1103 req, 1104 metadata=self.parent.get_metadata('Accounts.Update', req), 1105 timeout=t) 1106 except Exception as e: 1107 if self.parent.shouldRetry(tries, e, deadline): 1108 tries += 1 1109 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1110 continue 1111 raise plumbing.convert_error_to_porcelain(e) from e 1112 break 1113 1114 resp = models.AccountUpdateResponse() 1115 resp.account = plumbing.convert_account_to_porcelain( 1116 plumbing_response.account) 1117 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1118 plumbing_response.meta) 1119 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1120 plumbing_response.rate_limit) 1121 return resp 1122 1123 def delete(self, id, timeout=None): 1124 ''' 1125 Delete removes an Account by ID. 1126 ''' 1127 deadline = None if timeout is None else time.time() + timeout 1128 req = AccountDeleteRequest() 1129 1130 req.id = (id) 1131 tries = 0 1132 plumbing_response = None 1133 while True: 1134 t = None if deadline is None else deadline - time.time() 1135 try: 1136 plumbing_response = self.stub.Delete( 1137 req, 1138 metadata=self.parent.get_metadata('Accounts.Delete', req), 1139 timeout=t) 1140 except Exception as e: 1141 if self.parent.shouldRetry(tries, e, deadline): 1142 tries += 1 1143 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1144 continue 1145 raise plumbing.convert_error_to_porcelain(e) from e 1146 break 1147 1148 resp = models.AccountDeleteResponse() 1149 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1150 plumbing_response.meta) 1151 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1152 plumbing_response.rate_limit) 1153 return resp 1154 1155 def list(self, filter, *args, timeout=None): 1156 ''' 1157 List gets a list of Accounts matching a given set of criteria. 1158 ''' 1159 deadline = None if timeout is None else time.time() + timeout 1160 req = AccountListRequest() 1161 req.meta.CopyFrom(ListRequestMetadata()) 1162 if self.parent.page_limit > 0: 1163 req.meta.limit = self.parent.page_limit 1164 if self.parent.snapshot_datetime is not None: 1165 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1166 1167 req.filter = plumbing.quote_filter_args(filter, *args) 1168 1169 def generator(svc, req): 1170 tries = 0 1171 while True: 1172 t = None if deadline is None else deadline - time.time() 1173 try: 1174 plumbing_response = svc.stub.List( 1175 req, 1176 metadata=svc.parent.get_metadata('Accounts.List', req), 1177 timeout=t) 1178 except Exception as e: 1179 if self.parent.shouldRetry(tries, e, deadline): 1180 tries += 1 1181 time.sleep( 1182 self.parent.exponentialBackoff(tries, deadline)) 1183 continue 1184 raise plumbing.convert_error_to_porcelain(e) from e 1185 tries = 0 1186 for plumbing_item in plumbing_response.accounts: 1187 yield plumbing.convert_account_to_porcelain(plumbing_item) 1188 if plumbing_response.meta.next_cursor == '': 1189 break 1190 req.meta.cursor = plumbing_response.meta.next_cursor 1191 1192 return generator(self, req) 1193 1194 1195class SnapshotAccounts: 1196 ''' 1197 SnapshotAccounts exposes the read only methods of the Accounts 1198 service for historical queries. 1199 ''' 1200 def __init__(self, accounts): 1201 self.accounts = accounts 1202 1203 def get(self, id, timeout=None): 1204 ''' 1205 Get reads one Account by ID. 1206 ''' 1207 return self.accounts.get(id, timeout=timeout) 1208 1209 def list(self, filter, *args, timeout=None): 1210 ''' 1211 List gets a list of Accounts matching a given set of criteria. 1212 ''' 1213 return self.accounts.list(filter, *args, timeout=timeout) 1214 1215 1216class AccountsGroups: 1217 ''' 1218 An AccountGroup links an account and a group. 1219 See `strongdm.models.AccountGroup`. 1220 ''' 1221 def __init__(self, channel, client): 1222 self.parent = client 1223 self.stub = AccountsGroupsStub(channel) 1224 1225 def create(self, account_group, timeout=None): 1226 ''' 1227 Create create a new AccountGroup. 1228 ''' 1229 deadline = None if timeout is None else time.time() + timeout 1230 req = AccountGroupCreateRequest() 1231 1232 if account_group is not None: 1233 req.account_group.CopyFrom( 1234 plumbing.convert_account_group_to_plumbing(account_group)) 1235 tries = 0 1236 plumbing_response = None 1237 while True: 1238 t = None if deadline is None else deadline - time.time() 1239 try: 1240 plumbing_response = self.stub.Create( 1241 req, 1242 metadata=self.parent.get_metadata('AccountsGroups.Create', 1243 req), 1244 timeout=t) 1245 except Exception as e: 1246 if self.parent.shouldRetry(tries, e, deadline): 1247 tries += 1 1248 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1249 continue 1250 raise plumbing.convert_error_to_porcelain(e) from e 1251 break 1252 1253 resp = models.AccountGroupCreateResponse() 1254 resp.account_group = plumbing.convert_account_group_to_porcelain( 1255 plumbing_response.account_group) 1256 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1257 plumbing_response.rate_limit) 1258 return resp 1259 1260 def get(self, id, timeout=None): 1261 ''' 1262 Get reads one AccountGroup by ID. 1263 ''' 1264 deadline = None if timeout is None else time.time() + timeout 1265 req = AccountGroupGetRequest() 1266 if self.parent.snapshot_datetime is not None: 1267 req.meta.CopyFrom(GetRequestMetadata()) 1268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1269 1270 req.id = (id) 1271 tries = 0 1272 plumbing_response = None 1273 while True: 1274 t = None if deadline is None else deadline - time.time() 1275 try: 1276 plumbing_response = self.stub.Get( 1277 req, 1278 metadata=self.parent.get_metadata('AccountsGroups.Get', 1279 req), 1280 timeout=t) 1281 except Exception as e: 1282 if self.parent.shouldRetry(tries, e, deadline): 1283 tries += 1 1284 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1285 continue 1286 raise plumbing.convert_error_to_porcelain(e) from e 1287 break 1288 1289 resp = models.AccountGroupGetResponse() 1290 resp.account_group = plumbing.convert_account_group_to_porcelain( 1291 plumbing_response.account_group) 1292 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1293 plumbing_response.meta) 1294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1295 plumbing_response.rate_limit) 1296 return resp 1297 1298 def delete(self, id, timeout=None): 1299 ''' 1300 Delete removes an AccountGroup by ID. 1301 ''' 1302 deadline = None if timeout is None else time.time() + timeout 1303 req = AccountGroupDeleteRequest() 1304 1305 req.id = (id) 1306 tries = 0 1307 plumbing_response = None 1308 while True: 1309 t = None if deadline is None else deadline - time.time() 1310 try: 1311 plumbing_response = self.stub.Delete( 1312 req, 1313 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1314 req), 1315 timeout=t) 1316 except Exception as e: 1317 if self.parent.shouldRetry(tries, e, deadline): 1318 tries += 1 1319 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1320 continue 1321 raise plumbing.convert_error_to_porcelain(e) from e 1322 break 1323 1324 resp = models.AccountGroupDeleteResponse() 1325 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1326 plumbing_response.meta) 1327 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1328 plumbing_response.rate_limit) 1329 return resp 1330 1331 def list(self, filter, *args, timeout=None): 1332 ''' 1333 List gets a list of AccountGroups matching a given set of criteria. 1334 ''' 1335 deadline = None if timeout is None else time.time() + timeout 1336 req = AccountGroupListRequest() 1337 req.meta.CopyFrom(ListRequestMetadata()) 1338 if self.parent.page_limit > 0: 1339 req.meta.limit = self.parent.page_limit 1340 if self.parent.snapshot_datetime is not None: 1341 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1342 1343 req.filter = plumbing.quote_filter_args(filter, *args) 1344 1345 def generator(svc, req): 1346 tries = 0 1347 while True: 1348 t = None if deadline is None else deadline - time.time() 1349 try: 1350 plumbing_response = svc.stub.List( 1351 req, 1352 metadata=svc.parent.get_metadata( 1353 'AccountsGroups.List', req), 1354 timeout=t) 1355 except Exception as e: 1356 if self.parent.shouldRetry(tries, e, deadline): 1357 tries += 1 1358 time.sleep( 1359 self.parent.exponentialBackoff(tries, deadline)) 1360 continue 1361 raise plumbing.convert_error_to_porcelain(e) from e 1362 tries = 0 1363 for plumbing_item in plumbing_response.account_groups: 1364 yield plumbing.convert_account_group_to_porcelain( 1365 plumbing_item) 1366 if plumbing_response.meta.next_cursor == '': 1367 break 1368 req.meta.cursor = plumbing_response.meta.next_cursor 1369 1370 return generator(self, req) 1371 1372 1373class SnapshotAccountsGroups: 1374 ''' 1375 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1376 service for historical queries. 1377 ''' 1378 def __init__(self, accounts_groups): 1379 self.accounts_groups = accounts_groups 1380 1381 def get(self, id, timeout=None): 1382 ''' 1383 Get reads one AccountGroup by ID. 1384 ''' 1385 return self.accounts_groups.get(id, timeout=timeout) 1386 1387 def list(self, filter, *args, timeout=None): 1388 ''' 1389 List gets a list of AccountGroups matching a given set of criteria. 1390 ''' 1391 return self.accounts_groups.list(filter, *args, timeout=timeout) 1392 1393 1394class AccountsGroupsHistory: 1395 ''' 1396 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1397 See `strongdm.models.AccountGroupHistory`. 1398 ''' 1399 def __init__(self, channel, client): 1400 self.parent = client 1401 self.stub = AccountsGroupsHistoryStub(channel) 1402 1403 def list(self, filter, *args, timeout=None): 1404 ''' 1405 List gets a list of AccountGroupHistory records matching a given set of criteria. 1406 ''' 1407 deadline = None if timeout is None else time.time() + timeout 1408 req = AccountGroupHistoryListRequest() 1409 req.meta.CopyFrom(ListRequestMetadata()) 1410 if self.parent.page_limit > 0: 1411 req.meta.limit = self.parent.page_limit 1412 if self.parent.snapshot_datetime is not None: 1413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1414 1415 req.filter = plumbing.quote_filter_args(filter, *args) 1416 1417 def generator(svc, req): 1418 tries = 0 1419 while True: 1420 t = None if deadline is None else deadline - time.time() 1421 try: 1422 plumbing_response = svc.stub.List( 1423 req, 1424 metadata=svc.parent.get_metadata( 1425 'AccountsGroupsHistory.List', req), 1426 timeout=t) 1427 except Exception as e: 1428 if self.parent.shouldRetry(tries, e, deadline): 1429 tries += 1 1430 time.sleep( 1431 self.parent.exponentialBackoff(tries, deadline)) 1432 continue 1433 raise plumbing.convert_error_to_porcelain(e) from e 1434 tries = 0 1435 for plumbing_item in plumbing_response.history: 1436 yield plumbing.convert_account_group_history_to_porcelain( 1437 plumbing_item) 1438 if plumbing_response.meta.next_cursor == '': 1439 break 1440 req.meta.cursor = plumbing_response.meta.next_cursor 1441 1442 return generator(self, req) 1443 1444 1445class AccountsHistory: 1446 ''' 1447 AccountsHistory records all changes to the state of an Account. 1448 See `strongdm.models.AccountHistory`. 1449 ''' 1450 def __init__(self, channel, client): 1451 self.parent = client 1452 self.stub = AccountsHistoryStub(channel) 1453 1454 def list(self, filter, *args, timeout=None): 1455 ''' 1456 List gets a list of AccountHistory records matching a given set of criteria. 1457 ''' 1458 deadline = None if timeout is None else time.time() + timeout 1459 req = AccountHistoryListRequest() 1460 req.meta.CopyFrom(ListRequestMetadata()) 1461 if self.parent.page_limit > 0: 1462 req.meta.limit = self.parent.page_limit 1463 if self.parent.snapshot_datetime is not None: 1464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1465 1466 req.filter = plumbing.quote_filter_args(filter, *args) 1467 1468 def generator(svc, req): 1469 tries = 0 1470 while True: 1471 t = None if deadline is None else deadline - time.time() 1472 try: 1473 plumbing_response = svc.stub.List( 1474 req, 1475 metadata=svc.parent.get_metadata( 1476 'AccountsHistory.List', req), 1477 timeout=t) 1478 except Exception as e: 1479 if self.parent.shouldRetry(tries, e, deadline): 1480 tries += 1 1481 time.sleep( 1482 self.parent.exponentialBackoff(tries, deadline)) 1483 continue 1484 raise plumbing.convert_error_to_porcelain(e) from e 1485 tries = 0 1486 for plumbing_item in plumbing_response.history: 1487 yield plumbing.convert_account_history_to_porcelain( 1488 plumbing_item) 1489 if plumbing_response.meta.next_cursor == '': 1490 break 1491 req.meta.cursor = plumbing_response.meta.next_cursor 1492 1493 return generator(self, req) 1494 1495 1496class Activities: 1497 ''' 1498 An Activity is a record of an action taken against a strongDM deployment, e.g. 1499 a user creation, resource deletion, sso configuration change, etc. The Activities 1500 service is read-only. 1501 See `strongdm.models.Activity`. 1502 ''' 1503 def __init__(self, channel, client): 1504 self.parent = client 1505 self.stub = ActivitiesStub(channel) 1506 1507 def get(self, id, timeout=None): 1508 ''' 1509 Get reads one Activity by ID. 1510 ''' 1511 deadline = None if timeout is None else time.time() + timeout 1512 req = ActivityGetRequest() 1513 if self.parent.snapshot_datetime is not None: 1514 req.meta.CopyFrom(GetRequestMetadata()) 1515 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1516 1517 req.id = (id) 1518 tries = 0 1519 plumbing_response = None 1520 while True: 1521 t = None if deadline is None else deadline - time.time() 1522 try: 1523 plumbing_response = self.stub.Get( 1524 req, 1525 metadata=self.parent.get_metadata('Activities.Get', req), 1526 timeout=t) 1527 except Exception as e: 1528 if self.parent.shouldRetry(tries, e, deadline): 1529 tries += 1 1530 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1531 continue 1532 raise plumbing.convert_error_to_porcelain(e) from e 1533 break 1534 1535 resp = models.ActivityGetResponse() 1536 resp.activity = plumbing.convert_activity_to_porcelain( 1537 plumbing_response.activity) 1538 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1539 plumbing_response.meta) 1540 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1541 plumbing_response.rate_limit) 1542 return resp 1543 1544 def list(self, filter, *args, timeout=None): 1545 ''' 1546 List gets a list of Activities matching a given set of criteria. 1547 The 'before' and 'after' filters can be used to control the time 1548 range of the output activities. If not provided, one week of back 1549 of activities will be returned. 1550 ''' 1551 deadline = None if timeout is None else time.time() + timeout 1552 req = ActivityListRequest() 1553 req.meta.CopyFrom(ListRequestMetadata()) 1554 if self.parent.page_limit > 0: 1555 req.meta.limit = self.parent.page_limit 1556 if self.parent.snapshot_datetime is not None: 1557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1558 1559 req.filter = plumbing.quote_filter_args(filter, *args) 1560 1561 def generator(svc, req): 1562 tries = 0 1563 while True: 1564 t = None if deadline is None else deadline - time.time() 1565 try: 1566 plumbing_response = svc.stub.List( 1567 req, 1568 metadata=svc.parent.get_metadata( 1569 'Activities.List', req), 1570 timeout=t) 1571 except Exception as e: 1572 if self.parent.shouldRetry(tries, e, deadline): 1573 tries += 1 1574 time.sleep( 1575 self.parent.exponentialBackoff(tries, deadline)) 1576 continue 1577 raise plumbing.convert_error_to_porcelain(e) from e 1578 tries = 0 1579 for plumbing_item in plumbing_response.activities: 1580 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1581 if plumbing_response.meta.next_cursor == '': 1582 break 1583 req.meta.cursor = plumbing_response.meta.next_cursor 1584 1585 return generator(self, req) 1586 1587 1588class ApprovalWorkflowApprovers: 1589 ''' 1590 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1591 See `strongdm.models.ApprovalWorkflowApprover`. 1592 ''' 1593 def __init__(self, channel, client): 1594 self.parent = client 1595 self.stub = ApprovalWorkflowApproversStub(channel) 1596 1597 def create(self, approval_workflow_approver, timeout=None): 1598 ''' 1599 Deprecated: Create creates a new approval workflow approver. 1600 ''' 1601 deadline = None if timeout is None else time.time() + timeout 1602 req = ApprovalWorkflowApproverCreateRequest() 1603 1604 if approval_workflow_approver is not None: 1605 req.approval_workflow_approver.CopyFrom( 1606 plumbing.convert_approval_workflow_approver_to_plumbing( 1607 approval_workflow_approver)) 1608 tries = 0 1609 plumbing_response = None 1610 while True: 1611 t = None if deadline is None else deadline - time.time() 1612 try: 1613 plumbing_response = self.stub.Create( 1614 req, 1615 metadata=self.parent.get_metadata( 1616 'ApprovalWorkflowApprovers.Create', req), 1617 timeout=t) 1618 except Exception as e: 1619 if self.parent.shouldRetry(tries, e, deadline): 1620 tries += 1 1621 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1622 continue 1623 raise plumbing.convert_error_to_porcelain(e) from e 1624 break 1625 1626 resp = models.ApprovalWorkflowApproverCreateResponse() 1627 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1628 plumbing_response.approval_workflow_approver) 1629 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1630 plumbing_response.rate_limit) 1631 return resp 1632 1633 def get(self, id, timeout=None): 1634 ''' 1635 Deprecated: Get reads one approval workflow approver by ID. 1636 ''' 1637 deadline = None if timeout is None else time.time() + timeout 1638 req = ApprovalWorkflowApproverGetRequest() 1639 if self.parent.snapshot_datetime is not None: 1640 req.meta.CopyFrom(GetRequestMetadata()) 1641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1642 1643 req.id = (id) 1644 tries = 0 1645 plumbing_response = None 1646 while True: 1647 t = None if deadline is None else deadline - time.time() 1648 try: 1649 plumbing_response = self.stub.Get( 1650 req, 1651 metadata=self.parent.get_metadata( 1652 'ApprovalWorkflowApprovers.Get', req), 1653 timeout=t) 1654 except Exception as e: 1655 if self.parent.shouldRetry(tries, e, deadline): 1656 tries += 1 1657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1658 continue 1659 raise plumbing.convert_error_to_porcelain(e) from e 1660 break 1661 1662 resp = models.ApprovalWorkflowApproverGetResponse() 1663 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1664 plumbing_response.approval_workflow_approver) 1665 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1666 plumbing_response.meta) 1667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1668 plumbing_response.rate_limit) 1669 return resp 1670 1671 def delete(self, id, timeout=None): 1672 ''' 1673 Deprecated: Delete deletes an existing approval workflow approver. 1674 ''' 1675 deadline = None if timeout is None else time.time() + timeout 1676 req = ApprovalWorkflowApproverDeleteRequest() 1677 1678 req.id = (id) 1679 tries = 0 1680 plumbing_response = None 1681 while True: 1682 t = None if deadline is None else deadline - time.time() 1683 try: 1684 plumbing_response = self.stub.Delete( 1685 req, 1686 metadata=self.parent.get_metadata( 1687 'ApprovalWorkflowApprovers.Delete', req), 1688 timeout=t) 1689 except Exception as e: 1690 if self.parent.shouldRetry(tries, e, deadline): 1691 tries += 1 1692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1693 continue 1694 raise plumbing.convert_error_to_porcelain(e) from e 1695 break 1696 1697 resp = models.ApprovalWorkflowApproverDeleteResponse() 1698 resp.id = (plumbing_response.id) 1699 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1700 plumbing_response.rate_limit) 1701 return resp 1702 1703 def list(self, filter, *args, timeout=None): 1704 ''' 1705 Deprecated: Lists existing approval workflow approvers. 1706 ''' 1707 deadline = None if timeout is None else time.time() + timeout 1708 req = ApprovalWorkflowApproverListRequest() 1709 req.meta.CopyFrom(ListRequestMetadata()) 1710 if self.parent.page_limit > 0: 1711 req.meta.limit = self.parent.page_limit 1712 if self.parent.snapshot_datetime is not None: 1713 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1714 1715 req.filter = plumbing.quote_filter_args(filter, *args) 1716 1717 def generator(svc, req): 1718 tries = 0 1719 while True: 1720 t = None if deadline is None else deadline - time.time() 1721 try: 1722 plumbing_response = svc.stub.List( 1723 req, 1724 metadata=svc.parent.get_metadata( 1725 'ApprovalWorkflowApprovers.List', req), 1726 timeout=t) 1727 except Exception as e: 1728 if self.parent.shouldRetry(tries, e, deadline): 1729 tries += 1 1730 time.sleep( 1731 self.parent.exponentialBackoff(tries, deadline)) 1732 continue 1733 raise plumbing.convert_error_to_porcelain(e) from e 1734 tries = 0 1735 for plumbing_item in plumbing_response.approval_workflow_approvers: 1736 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1737 plumbing_item) 1738 if plumbing_response.meta.next_cursor == '': 1739 break 1740 req.meta.cursor = plumbing_response.meta.next_cursor 1741 1742 return generator(self, req) 1743 1744 1745class SnapshotApprovalWorkflowApprovers: 1746 ''' 1747 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1748 service for historical queries. 1749 ''' 1750 def __init__(self, approval_workflow_approvers): 1751 self.approval_workflow_approvers = approval_workflow_approvers 1752 1753 def get(self, id, timeout=None): 1754 ''' 1755 Deprecated: Get reads one approval workflow approver by ID. 1756 ''' 1757 return self.approval_workflow_approvers.get(id, timeout=timeout) 1758 1759 def list(self, filter, *args, timeout=None): 1760 ''' 1761 Deprecated: Lists existing approval workflow approvers. 1762 ''' 1763 return self.approval_workflow_approvers.list(filter, 1764 *args, 1765 timeout=timeout) 1766 1767 1768class ApprovalWorkflowApproversHistory: 1769 ''' 1770 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1771 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1772 ''' 1773 def __init__(self, channel, client): 1774 self.parent = client 1775 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1776 1777 def list(self, filter, *args, timeout=None): 1778 ''' 1779 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1780 ''' 1781 deadline = None if timeout is None else time.time() + timeout 1782 req = ApprovalWorkflowApproverHistoryListRequest() 1783 req.meta.CopyFrom(ListRequestMetadata()) 1784 if self.parent.page_limit > 0: 1785 req.meta.limit = self.parent.page_limit 1786 if self.parent.snapshot_datetime is not None: 1787 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1788 1789 req.filter = plumbing.quote_filter_args(filter, *args) 1790 1791 def generator(svc, req): 1792 tries = 0 1793 while True: 1794 t = None if deadline is None else deadline - time.time() 1795 try: 1796 plumbing_response = svc.stub.List( 1797 req, 1798 metadata=svc.parent.get_metadata( 1799 'ApprovalWorkflowApproversHistory.List', req), 1800 timeout=t) 1801 except Exception as e: 1802 if self.parent.shouldRetry(tries, e, deadline): 1803 tries += 1 1804 time.sleep( 1805 self.parent.exponentialBackoff(tries, deadline)) 1806 continue 1807 raise plumbing.convert_error_to_porcelain(e) from e 1808 tries = 0 1809 for plumbing_item in plumbing_response.history: 1810 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1811 plumbing_item) 1812 if plumbing_response.meta.next_cursor == '': 1813 break 1814 req.meta.cursor = plumbing_response.meta.next_cursor 1815 1816 return generator(self, req) 1817 1818 1819class ApprovalWorkflowSteps: 1820 ''' 1821 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1822 See `strongdm.models.ApprovalWorkflowStep`. 1823 ''' 1824 def __init__(self, channel, client): 1825 self.parent = client 1826 self.stub = ApprovalWorkflowStepsStub(channel) 1827 1828 def create(self, approval_workflow_step, timeout=None): 1829 ''' 1830 Deprecated: Create creates a new approval workflow step. 1831 ''' 1832 deadline = None if timeout is None else time.time() + timeout 1833 req = ApprovalWorkflowStepCreateRequest() 1834 1835 if approval_workflow_step is not None: 1836 req.approval_workflow_step.CopyFrom( 1837 plumbing.convert_approval_workflow_step_to_plumbing( 1838 approval_workflow_step)) 1839 tries = 0 1840 plumbing_response = None 1841 while True: 1842 t = None if deadline is None else deadline - time.time() 1843 try: 1844 plumbing_response = self.stub.Create( 1845 req, 1846 metadata=self.parent.get_metadata( 1847 'ApprovalWorkflowSteps.Create', req), 1848 timeout=t) 1849 except Exception as e: 1850 if self.parent.shouldRetry(tries, e, deadline): 1851 tries += 1 1852 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1853 continue 1854 raise plumbing.convert_error_to_porcelain(e) from e 1855 break 1856 1857 resp = models.ApprovalWorkflowStepCreateResponse() 1858 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1859 plumbing_response.approval_workflow_step) 1860 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1861 plumbing_response.rate_limit) 1862 return resp 1863 1864 def get(self, id, timeout=None): 1865 ''' 1866 Deprecated: Get reads one approval workflow step by ID. 1867 ''' 1868 deadline = None if timeout is None else time.time() + timeout 1869 req = ApprovalWorkflowStepGetRequest() 1870 if self.parent.snapshot_datetime is not None: 1871 req.meta.CopyFrom(GetRequestMetadata()) 1872 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1873 1874 req.id = (id) 1875 tries = 0 1876 plumbing_response = None 1877 while True: 1878 t = None if deadline is None else deadline - time.time() 1879 try: 1880 plumbing_response = self.stub.Get( 1881 req, 1882 metadata=self.parent.get_metadata( 1883 'ApprovalWorkflowSteps.Get', req), 1884 timeout=t) 1885 except Exception as e: 1886 if self.parent.shouldRetry(tries, e, deadline): 1887 tries += 1 1888 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1889 continue 1890 raise plumbing.convert_error_to_porcelain(e) from e 1891 break 1892 1893 resp = models.ApprovalWorkflowStepGetResponse() 1894 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1895 plumbing_response.approval_workflow_step) 1896 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1897 plumbing_response.meta) 1898 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1899 plumbing_response.rate_limit) 1900 return resp 1901 1902 def delete(self, id, timeout=None): 1903 ''' 1904 Deprecated: Delete deletes an existing approval workflow step. 1905 ''' 1906 deadline = None if timeout is None else time.time() + timeout 1907 req = ApprovalWorkflowStepDeleteRequest() 1908 1909 req.id = (id) 1910 tries = 0 1911 plumbing_response = None 1912 while True: 1913 t = None if deadline is None else deadline - time.time() 1914 try: 1915 plumbing_response = self.stub.Delete( 1916 req, 1917 metadata=self.parent.get_metadata( 1918 'ApprovalWorkflowSteps.Delete', req), 1919 timeout=t) 1920 except Exception as e: 1921 if self.parent.shouldRetry(tries, e, deadline): 1922 tries += 1 1923 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1924 continue 1925 raise plumbing.convert_error_to_porcelain(e) from e 1926 break 1927 1928 resp = models.ApprovalWorkflowStepDeleteResponse() 1929 resp.id = (plumbing_response.id) 1930 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1931 plumbing_response.rate_limit) 1932 return resp 1933 1934 def list(self, filter, *args, timeout=None): 1935 ''' 1936 Deprecated: Lists existing approval workflow steps. 1937 ''' 1938 deadline = None if timeout is None else time.time() + timeout 1939 req = ApprovalWorkflowStepListRequest() 1940 req.meta.CopyFrom(ListRequestMetadata()) 1941 if self.parent.page_limit > 0: 1942 req.meta.limit = self.parent.page_limit 1943 if self.parent.snapshot_datetime is not None: 1944 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1945 1946 req.filter = plumbing.quote_filter_args(filter, *args) 1947 1948 def generator(svc, req): 1949 tries = 0 1950 while True: 1951 t = None if deadline is None else deadline - time.time() 1952 try: 1953 plumbing_response = svc.stub.List( 1954 req, 1955 metadata=svc.parent.get_metadata( 1956 'ApprovalWorkflowSteps.List', req), 1957 timeout=t) 1958 except Exception as e: 1959 if self.parent.shouldRetry(tries, e, deadline): 1960 tries += 1 1961 time.sleep( 1962 self.parent.exponentialBackoff(tries, deadline)) 1963 continue 1964 raise plumbing.convert_error_to_porcelain(e) from e 1965 tries = 0 1966 for plumbing_item in plumbing_response.approval_workflow_steps: 1967 yield plumbing.convert_approval_workflow_step_to_porcelain( 1968 plumbing_item) 1969 if plumbing_response.meta.next_cursor == '': 1970 break 1971 req.meta.cursor = plumbing_response.meta.next_cursor 1972 1973 return generator(self, req) 1974 1975 1976class SnapshotApprovalWorkflowSteps: 1977 ''' 1978 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1979 service for historical queries. 1980 ''' 1981 def __init__(self, approval_workflow_steps): 1982 self.approval_workflow_steps = approval_workflow_steps 1983 1984 def get(self, id, timeout=None): 1985 ''' 1986 Deprecated: Get reads one approval workflow step by ID. 1987 ''' 1988 return self.approval_workflow_steps.get(id, timeout=timeout) 1989 1990 def list(self, filter, *args, timeout=None): 1991 ''' 1992 Deprecated: Lists existing approval workflow steps. 1993 ''' 1994 return self.approval_workflow_steps.list(filter, 1995 *args, 1996 timeout=timeout) 1997 1998 1999class ApprovalWorkflowStepsHistory: 2000 ''' 2001 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2002 See `strongdm.models.ApprovalWorkflowStepHistory`. 2003 ''' 2004 def __init__(self, channel, client): 2005 self.parent = client 2006 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2007 2008 def list(self, filter, *args, timeout=None): 2009 ''' 2010 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2011 ''' 2012 deadline = None if timeout is None else time.time() + timeout 2013 req = ApprovalWorkflowStepHistoryListRequest() 2014 req.meta.CopyFrom(ListRequestMetadata()) 2015 if self.parent.page_limit > 0: 2016 req.meta.limit = self.parent.page_limit 2017 if self.parent.snapshot_datetime is not None: 2018 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2019 2020 req.filter = plumbing.quote_filter_args(filter, *args) 2021 2022 def generator(svc, req): 2023 tries = 0 2024 while True: 2025 t = None if deadline is None else deadline - time.time() 2026 try: 2027 plumbing_response = svc.stub.List( 2028 req, 2029 metadata=svc.parent.get_metadata( 2030 'ApprovalWorkflowStepsHistory.List', req), 2031 timeout=t) 2032 except Exception as e: 2033 if self.parent.shouldRetry(tries, e, deadline): 2034 tries += 1 2035 time.sleep( 2036 self.parent.exponentialBackoff(tries, deadline)) 2037 continue 2038 raise plumbing.convert_error_to_porcelain(e) from e 2039 tries = 0 2040 for plumbing_item in plumbing_response.history: 2041 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2042 plumbing_item) 2043 if plumbing_response.meta.next_cursor == '': 2044 break 2045 req.meta.cursor = plumbing_response.meta.next_cursor 2046 2047 return generator(self, req) 2048 2049 2050class ApprovalWorkflows: 2051 ''' 2052 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2053 approvers and be approved or denied. 2054 See `strongdm.models.ApprovalWorkflow`. 2055 ''' 2056 def __init__(self, channel, client): 2057 self.parent = client 2058 self.stub = ApprovalWorkflowsStub(channel) 2059 2060 def create(self, approval_workflow, timeout=None): 2061 ''' 2062 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2063 ''' 2064 deadline = None if timeout is None else time.time() + timeout 2065 req = ApprovalWorkflowCreateRequest() 2066 2067 if approval_workflow is not None: 2068 req.approval_workflow.CopyFrom( 2069 plumbing.convert_approval_workflow_to_plumbing( 2070 approval_workflow)) 2071 tries = 0 2072 plumbing_response = None 2073 while True: 2074 t = None if deadline is None else deadline - time.time() 2075 try: 2076 plumbing_response = self.stub.Create( 2077 req, 2078 metadata=self.parent.get_metadata( 2079 'ApprovalWorkflows.Create', req), 2080 timeout=t) 2081 except Exception as e: 2082 if self.parent.shouldRetry(tries, e, deadline): 2083 tries += 1 2084 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2085 continue 2086 raise plumbing.convert_error_to_porcelain(e) from e 2087 break 2088 2089 resp = models.ApprovalWorkflowCreateResponse() 2090 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2091 plumbing_response.approval_workflow) 2092 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2093 plumbing_response.rate_limit) 2094 return resp 2095 2096 def get(self, id, timeout=None): 2097 ''' 2098 Get reads one approval workflow by ID. 2099 ''' 2100 deadline = None if timeout is None else time.time() + timeout 2101 req = ApprovalWorkflowGetRequest() 2102 if self.parent.snapshot_datetime is not None: 2103 req.meta.CopyFrom(GetRequestMetadata()) 2104 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2105 2106 req.id = (id) 2107 tries = 0 2108 plumbing_response = None 2109 while True: 2110 t = None if deadline is None else deadline - time.time() 2111 try: 2112 plumbing_response = self.stub.Get( 2113 req, 2114 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2115 req), 2116 timeout=t) 2117 except Exception as e: 2118 if self.parent.shouldRetry(tries, e, deadline): 2119 tries += 1 2120 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2121 continue 2122 raise plumbing.convert_error_to_porcelain(e) from e 2123 break 2124 2125 resp = models.ApprovalWorkflowGetResponse() 2126 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2127 plumbing_response.approval_workflow) 2128 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2129 plumbing_response.meta) 2130 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2131 plumbing_response.rate_limit) 2132 return resp 2133 2134 def delete(self, id, timeout=None): 2135 ''' 2136 Delete deletes an existing approval workflow. 2137 ''' 2138 deadline = None if timeout is None else time.time() + timeout 2139 req = ApprovalWorkflowDeleteRequest() 2140 2141 req.id = (id) 2142 tries = 0 2143 plumbing_response = None 2144 while True: 2145 t = None if deadline is None else deadline - time.time() 2146 try: 2147 plumbing_response = self.stub.Delete( 2148 req, 2149 metadata=self.parent.get_metadata( 2150 'ApprovalWorkflows.Delete', req), 2151 timeout=t) 2152 except Exception as e: 2153 if self.parent.shouldRetry(tries, e, deadline): 2154 tries += 1 2155 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2156 continue 2157 raise plumbing.convert_error_to_porcelain(e) from e 2158 break 2159 2160 resp = models.ApprovalWorkflowDeleteResponse() 2161 resp.id = (plumbing_response.id) 2162 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2163 plumbing_response.rate_limit) 2164 return resp 2165 2166 def update(self, approval_workflow, timeout=None): 2167 ''' 2168 Update updates an existing approval workflow. 2169 ''' 2170 deadline = None if timeout is None else time.time() + timeout 2171 req = ApprovalWorkflowUpdateRequest() 2172 2173 if approval_workflow is not None: 2174 req.approval_workflow.CopyFrom( 2175 plumbing.convert_approval_workflow_to_plumbing( 2176 approval_workflow)) 2177 tries = 0 2178 plumbing_response = None 2179 while True: 2180 t = None if deadline is None else deadline - time.time() 2181 try: 2182 plumbing_response = self.stub.Update( 2183 req, 2184 metadata=self.parent.get_metadata( 2185 'ApprovalWorkflows.Update', req), 2186 timeout=t) 2187 except Exception as e: 2188 if self.parent.shouldRetry(tries, e, deadline): 2189 tries += 1 2190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2191 continue 2192 raise plumbing.convert_error_to_porcelain(e) from e 2193 break 2194 2195 resp = models.ApprovalWorkflowUpdateResponse() 2196 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2197 plumbing_response.approval_workflow) 2198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2199 plumbing_response.rate_limit) 2200 return resp 2201 2202 def list(self, filter, *args, timeout=None): 2203 ''' 2204 Lists existing approval workflows. 2205 ''' 2206 deadline = None if timeout is None else time.time() + timeout 2207 req = ApprovalWorkflowListRequest() 2208 req.meta.CopyFrom(ListRequestMetadata()) 2209 if self.parent.page_limit > 0: 2210 req.meta.limit = self.parent.page_limit 2211 if self.parent.snapshot_datetime is not None: 2212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2213 2214 req.filter = plumbing.quote_filter_args(filter, *args) 2215 2216 def generator(svc, req): 2217 tries = 0 2218 while True: 2219 t = None if deadline is None else deadline - time.time() 2220 try: 2221 plumbing_response = svc.stub.List( 2222 req, 2223 metadata=svc.parent.get_metadata( 2224 'ApprovalWorkflows.List', req), 2225 timeout=t) 2226 except Exception as e: 2227 if self.parent.shouldRetry(tries, e, deadline): 2228 tries += 1 2229 time.sleep( 2230 self.parent.exponentialBackoff(tries, deadline)) 2231 continue 2232 raise plumbing.convert_error_to_porcelain(e) from e 2233 tries = 0 2234 for plumbing_item in plumbing_response.approval_workflows: 2235 yield plumbing.convert_approval_workflow_to_porcelain( 2236 plumbing_item) 2237 if plumbing_response.meta.next_cursor == '': 2238 break 2239 req.meta.cursor = plumbing_response.meta.next_cursor 2240 2241 return generator(self, req) 2242 2243 2244class SnapshotApprovalWorkflows: 2245 ''' 2246 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2247 service for historical queries. 2248 ''' 2249 def __init__(self, approval_workflows): 2250 self.approval_workflows = approval_workflows 2251 2252 def get(self, id, timeout=None): 2253 ''' 2254 Get reads one approval workflow by ID. 2255 ''' 2256 return self.approval_workflows.get(id, timeout=timeout) 2257 2258 def list(self, filter, *args, timeout=None): 2259 ''' 2260 Lists existing approval workflows. 2261 ''' 2262 return self.approval_workflows.list(filter, *args, timeout=timeout) 2263 2264 2265class ApprovalWorkflowsHistory: 2266 ''' 2267 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2268 See `strongdm.models.ApprovalWorkflowHistory`. 2269 ''' 2270 def __init__(self, channel, client): 2271 self.parent = client 2272 self.stub = ApprovalWorkflowsHistoryStub(channel) 2273 2274 def list(self, filter, *args, timeout=None): 2275 ''' 2276 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2277 ''' 2278 deadline = None if timeout is None else time.time() + timeout 2279 req = ApprovalWorkflowHistoryListRequest() 2280 req.meta.CopyFrom(ListRequestMetadata()) 2281 if self.parent.page_limit > 0: 2282 req.meta.limit = self.parent.page_limit 2283 if self.parent.snapshot_datetime is not None: 2284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2285 2286 req.filter = plumbing.quote_filter_args(filter, *args) 2287 2288 def generator(svc, req): 2289 tries = 0 2290 while True: 2291 t = None if deadline is None else deadline - time.time() 2292 try: 2293 plumbing_response = svc.stub.List( 2294 req, 2295 metadata=svc.parent.get_metadata( 2296 'ApprovalWorkflowsHistory.List', req), 2297 timeout=t) 2298 except Exception as e: 2299 if self.parent.shouldRetry(tries, e, deadline): 2300 tries += 1 2301 time.sleep( 2302 self.parent.exponentialBackoff(tries, deadline)) 2303 continue 2304 raise plumbing.convert_error_to_porcelain(e) from e 2305 tries = 0 2306 for plumbing_item in plumbing_response.history: 2307 yield plumbing.convert_approval_workflow_history_to_porcelain( 2308 plumbing_item) 2309 if plumbing_response.meta.next_cursor == '': 2310 break 2311 req.meta.cursor = plumbing_response.meta.next_cursor 2312 2313 return generator(self, req) 2314 2315 2316class ControlPanel: 2317 ''' 2318 ControlPanel contains all administrative controls. 2319 ''' 2320 def __init__(self, channel, client): 2321 self.parent = client 2322 self.stub = ControlPanelStub(channel) 2323 2324 def get_sshca_public_key(self, timeout=None): 2325 ''' 2326 GetSSHCAPublicKey retrieves the SSH CA public key. 2327 ''' 2328 deadline = None if timeout is None else time.time() + timeout 2329 req = ControlPanelGetSSHCAPublicKeyRequest() 2330 2331 tries = 0 2332 plumbing_response = None 2333 while True: 2334 t = None if deadline is None else deadline - time.time() 2335 try: 2336 plumbing_response = self.stub.GetSSHCAPublicKey( 2337 req, 2338 metadata=self.parent.get_metadata( 2339 'ControlPanel.GetSSHCAPublicKey', req), 2340 timeout=t) 2341 except Exception as e: 2342 if self.parent.shouldRetry(tries, e, deadline): 2343 tries += 1 2344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2345 continue 2346 raise plumbing.convert_error_to_porcelain(e) from e 2347 break 2348 2349 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2350 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2351 plumbing_response.meta) 2352 resp.public_key = (plumbing_response.public_key) 2353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2354 plumbing_response.rate_limit) 2355 return resp 2356 2357 def get_rdpca_public_key(self, timeout=None): 2358 ''' 2359 GetRDPCAPublicKey retrieves the RDP CA public key. 2360 ''' 2361 deadline = None if timeout is None else time.time() + timeout 2362 req = ControlPanelGetRDPCAPublicKeyRequest() 2363 2364 tries = 0 2365 plumbing_response = None 2366 while True: 2367 t = None if deadline is None else deadline - time.time() 2368 try: 2369 plumbing_response = self.stub.GetRDPCAPublicKey( 2370 req, 2371 metadata=self.parent.get_metadata( 2372 'ControlPanel.GetRDPCAPublicKey', req), 2373 timeout=t) 2374 except Exception as e: 2375 if self.parent.shouldRetry(tries, e, deadline): 2376 tries += 1 2377 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2378 continue 2379 raise plumbing.convert_error_to_porcelain(e) from e 2380 break 2381 2382 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2383 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2384 plumbing_response.meta) 2385 resp.public_key = (plumbing_response.public_key) 2386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2387 plumbing_response.rate_limit) 2388 return resp 2389 2390 def verify_jwt(self, token, timeout=None): 2391 ''' 2392 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2393 ''' 2394 deadline = None if timeout is None else time.time() + timeout 2395 req = ControlPanelVerifyJWTRequest() 2396 2397 req.token = (token) 2398 tries = 0 2399 plumbing_response = None 2400 while True: 2401 t = None if deadline is None else deadline - time.time() 2402 try: 2403 plumbing_response = self.stub.VerifyJWT( 2404 req, 2405 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2406 req), 2407 timeout=t) 2408 except Exception as e: 2409 if self.parent.shouldRetry(tries, e, deadline): 2410 tries += 1 2411 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2412 continue 2413 raise plumbing.convert_error_to_porcelain(e) from e 2414 break 2415 2416 resp = models.ControlPanelVerifyJWTResponse() 2417 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2418 plumbing_response.meta) 2419 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2420 plumbing_response.rate_limit) 2421 resp.valid = (plumbing_response.valid) 2422 return resp 2423 2424 2425class Roles: 2426 ''' 2427 A Role has a list of access rules which determine which Resources the members 2428 of the Role have access to. An Account can be a member of multiple Roles via 2429 AccountAttachments. 2430 See `strongdm.models.Role`. 2431 ''' 2432 def __init__(self, channel, client): 2433 self.parent = client 2434 self.stub = RolesStub(channel) 2435 2436 def create(self, role, timeout=None): 2437 ''' 2438 Create registers a new Role. 2439 ''' 2440 deadline = None if timeout is None else time.time() + timeout 2441 req = RoleCreateRequest() 2442 2443 if role is not None: 2444 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2445 tries = 0 2446 plumbing_response = None 2447 while True: 2448 t = None if deadline is None else deadline - time.time() 2449 try: 2450 plumbing_response = self.stub.Create( 2451 req, 2452 metadata=self.parent.get_metadata('Roles.Create', req), 2453 timeout=t) 2454 except Exception as e: 2455 if self.parent.shouldRetry(tries, e, deadline): 2456 tries += 1 2457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2458 continue 2459 raise plumbing.convert_error_to_porcelain(e) from e 2460 break 2461 2462 resp = models.RoleCreateResponse() 2463 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2464 plumbing_response.meta) 2465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2466 plumbing_response.rate_limit) 2467 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2468 return resp 2469 2470 def get(self, id, timeout=None): 2471 ''' 2472 Get reads one Role by ID. 2473 ''' 2474 deadline = None if timeout is None else time.time() + timeout 2475 req = RoleGetRequest() 2476 if self.parent.snapshot_datetime is not None: 2477 req.meta.CopyFrom(GetRequestMetadata()) 2478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2479 2480 req.id = (id) 2481 tries = 0 2482 plumbing_response = None 2483 while True: 2484 t = None if deadline is None else deadline - time.time() 2485 try: 2486 plumbing_response = self.stub.Get( 2487 req, 2488 metadata=self.parent.get_metadata('Roles.Get', req), 2489 timeout=t) 2490 except Exception as e: 2491 if self.parent.shouldRetry(tries, e, deadline): 2492 tries += 1 2493 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2494 continue 2495 raise plumbing.convert_error_to_porcelain(e) from e 2496 break 2497 2498 resp = models.RoleGetResponse() 2499 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2500 plumbing_response.meta) 2501 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2502 plumbing_response.rate_limit) 2503 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2504 return resp 2505 2506 def update(self, role, timeout=None): 2507 ''' 2508 Update replaces all the fields of a Role by ID. 2509 ''' 2510 deadline = None if timeout is None else time.time() + timeout 2511 req = RoleUpdateRequest() 2512 2513 if role is not None: 2514 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2515 tries = 0 2516 plumbing_response = None 2517 while True: 2518 t = None if deadline is None else deadline - time.time() 2519 try: 2520 plumbing_response = self.stub.Update( 2521 req, 2522 metadata=self.parent.get_metadata('Roles.Update', req), 2523 timeout=t) 2524 except Exception as e: 2525 if self.parent.shouldRetry(tries, e, deadline): 2526 tries += 1 2527 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2528 continue 2529 raise plumbing.convert_error_to_porcelain(e) from e 2530 break 2531 2532 resp = models.RoleUpdateResponse() 2533 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2534 plumbing_response.meta) 2535 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2536 plumbing_response.rate_limit) 2537 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2538 return resp 2539 2540 def delete(self, id, timeout=None): 2541 ''' 2542 Delete removes a Role by ID. 2543 ''' 2544 deadline = None if timeout is None else time.time() + timeout 2545 req = RoleDeleteRequest() 2546 2547 req.id = (id) 2548 tries = 0 2549 plumbing_response = None 2550 while True: 2551 t = None if deadline is None else deadline - time.time() 2552 try: 2553 plumbing_response = self.stub.Delete( 2554 req, 2555 metadata=self.parent.get_metadata('Roles.Delete', req), 2556 timeout=t) 2557 except Exception as e: 2558 if self.parent.shouldRetry(tries, e, deadline): 2559 tries += 1 2560 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2561 continue 2562 raise plumbing.convert_error_to_porcelain(e) from e 2563 break 2564 2565 resp = models.RoleDeleteResponse() 2566 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2567 plumbing_response.meta) 2568 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2569 plumbing_response.rate_limit) 2570 return resp 2571 2572 def list(self, filter, *args, timeout=None): 2573 ''' 2574 List gets a list of Roles matching a given set of criteria. 2575 ''' 2576 deadline = None if timeout is None else time.time() + timeout 2577 req = RoleListRequest() 2578 req.meta.CopyFrom(ListRequestMetadata()) 2579 if self.parent.page_limit > 0: 2580 req.meta.limit = self.parent.page_limit 2581 if self.parent.snapshot_datetime is not None: 2582 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2583 2584 req.filter = plumbing.quote_filter_args(filter, *args) 2585 2586 def generator(svc, req): 2587 tries = 0 2588 while True: 2589 t = None if deadline is None else deadline - time.time() 2590 try: 2591 plumbing_response = svc.stub.List( 2592 req, 2593 metadata=svc.parent.get_metadata('Roles.List', req), 2594 timeout=t) 2595 except Exception as e: 2596 if self.parent.shouldRetry(tries, e, deadline): 2597 tries += 1 2598 time.sleep( 2599 self.parent.exponentialBackoff(tries, deadline)) 2600 continue 2601 raise plumbing.convert_error_to_porcelain(e) from e 2602 tries = 0 2603 for plumbing_item in plumbing_response.roles: 2604 yield plumbing.convert_role_to_porcelain(plumbing_item) 2605 if plumbing_response.meta.next_cursor == '': 2606 break 2607 req.meta.cursor = plumbing_response.meta.next_cursor 2608 2609 return generator(self, req) 2610 2611 2612class SnapshotRoles: 2613 ''' 2614 SnapshotRoles exposes the read only methods of the Roles 2615 service for historical queries. 2616 ''' 2617 def __init__(self, roles): 2618 self.roles = roles 2619 2620 def get(self, id, timeout=None): 2621 ''' 2622 Get reads one Role by ID. 2623 ''' 2624 return self.roles.get(id, timeout=timeout) 2625 2626 def list(self, filter, *args, timeout=None): 2627 ''' 2628 List gets a list of Roles matching a given set of criteria. 2629 ''' 2630 return self.roles.list(filter, *args, timeout=timeout) 2631 2632 2633class Groups: 2634 ''' 2635 A Group is a set of principals. 2636 See `strongdm.models.Group`. 2637 ''' 2638 def __init__(self, channel, client): 2639 self.parent = client 2640 self.stub = GroupsStub(channel) 2641 2642 def create(self, group, timeout=None): 2643 ''' 2644 Create registers a new Group. 2645 ''' 2646 deadline = None if timeout is None else time.time() + timeout 2647 req = GroupCreateRequest() 2648 2649 if group is not None: 2650 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2651 tries = 0 2652 plumbing_response = None 2653 while True: 2654 t = None if deadline is None else deadline - time.time() 2655 try: 2656 plumbing_response = self.stub.Create( 2657 req, 2658 metadata=self.parent.get_metadata('Groups.Create', req), 2659 timeout=t) 2660 except Exception as e: 2661 if self.parent.shouldRetry(tries, e, deadline): 2662 tries += 1 2663 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2664 continue 2665 raise plumbing.convert_error_to_porcelain(e) from e 2666 break 2667 2668 resp = models.GroupCreateResponse() 2669 resp.group = plumbing.convert_group_to_porcelain( 2670 plumbing_response.group) 2671 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2672 plumbing_response.rate_limit) 2673 return resp 2674 2675 def create_from_roles(self, role_ids, commit, timeout=None): 2676 deadline = None if timeout is None else time.time() + timeout 2677 req = GroupCreateFromRolesRequest() 2678 2679 req.role_ids.extend((role_ids)) 2680 req.commit = (commit) 2681 tries = 0 2682 plumbing_response = None 2683 while True: 2684 t = None if deadline is None else deadline - time.time() 2685 try: 2686 plumbing_response = self.stub.CreateFromRoles( 2687 req, 2688 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2689 req), 2690 timeout=t) 2691 except Exception as e: 2692 if self.parent.shouldRetry(tries, e, deadline): 2693 tries += 1 2694 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2695 continue 2696 raise plumbing.convert_error_to_porcelain(e) from e 2697 break 2698 2699 resp = models.GroupCreateFromRolesResponse() 2700 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2701 plumbing_response.group_from_role) 2702 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2703 plumbing_response.rate_limit) 2704 return resp 2705 2706 def get(self, id, timeout=None): 2707 ''' 2708 Get reads one Group by ID. 2709 ''' 2710 deadline = None if timeout is None else time.time() + timeout 2711 req = GroupGetRequest() 2712 if self.parent.snapshot_datetime is not None: 2713 req.meta.CopyFrom(GetRequestMetadata()) 2714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2715 2716 req.id = (id) 2717 tries = 0 2718 plumbing_response = None 2719 while True: 2720 t = None if deadline is None else deadline - time.time() 2721 try: 2722 plumbing_response = self.stub.Get( 2723 req, 2724 metadata=self.parent.get_metadata('Groups.Get', req), 2725 timeout=t) 2726 except Exception as e: 2727 if self.parent.shouldRetry(tries, e, deadline): 2728 tries += 1 2729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2730 continue 2731 raise plumbing.convert_error_to_porcelain(e) from e 2732 break 2733 2734 resp = models.GroupGetResponse() 2735 resp.group = plumbing.convert_group_to_porcelain( 2736 plumbing_response.group) 2737 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2738 plumbing_response.meta) 2739 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2740 plumbing_response.rate_limit) 2741 return resp 2742 2743 def update(self, group, timeout=None): 2744 ''' 2745 Update replaces all the fields of a Group by ID. 2746 ''' 2747 deadline = None if timeout is None else time.time() + timeout 2748 req = GroupUpdateRequest() 2749 2750 if group is not None: 2751 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2752 tries = 0 2753 plumbing_response = None 2754 while True: 2755 t = None if deadline is None else deadline - time.time() 2756 try: 2757 plumbing_response = self.stub.Update( 2758 req, 2759 metadata=self.parent.get_metadata('Groups.Update', req), 2760 timeout=t) 2761 except Exception as e: 2762 if self.parent.shouldRetry(tries, e, deadline): 2763 tries += 1 2764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2765 continue 2766 raise plumbing.convert_error_to_porcelain(e) from e 2767 break 2768 2769 resp = models.GroupUpdateResponse() 2770 resp.group = plumbing.convert_group_to_porcelain( 2771 plumbing_response.group) 2772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2773 plumbing_response.rate_limit) 2774 return resp 2775 2776 def delete(self, id, timeout=None): 2777 ''' 2778 Delete removes a Group by ID. 2779 ''' 2780 deadline = None if timeout is None else time.time() + timeout 2781 req = GroupDeleteRequest() 2782 2783 req.id = (id) 2784 tries = 0 2785 plumbing_response = None 2786 while True: 2787 t = None if deadline is None else deadline - time.time() 2788 try: 2789 plumbing_response = self.stub.Delete( 2790 req, 2791 metadata=self.parent.get_metadata('Groups.Delete', req), 2792 timeout=t) 2793 except Exception as e: 2794 if self.parent.shouldRetry(tries, e, deadline): 2795 tries += 1 2796 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2797 continue 2798 raise plumbing.convert_error_to_porcelain(e) from e 2799 break 2800 2801 resp = models.GroupDeleteResponse() 2802 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2803 plumbing_response.meta) 2804 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2805 plumbing_response.rate_limit) 2806 return resp 2807 2808 def list(self, filter, *args, timeout=None): 2809 ''' 2810 List gets a list of Groups matching a given set of criteria. 2811 ''' 2812 deadline = None if timeout is None else time.time() + timeout 2813 req = GroupListRequest() 2814 req.meta.CopyFrom(ListRequestMetadata()) 2815 if self.parent.page_limit > 0: 2816 req.meta.limit = self.parent.page_limit 2817 if self.parent.snapshot_datetime is not None: 2818 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2819 2820 req.filter = plumbing.quote_filter_args(filter, *args) 2821 2822 def generator(svc, req): 2823 tries = 0 2824 while True: 2825 t = None if deadline is None else deadline - time.time() 2826 try: 2827 plumbing_response = svc.stub.List( 2828 req, 2829 metadata=svc.parent.get_metadata('Groups.List', req), 2830 timeout=t) 2831 except Exception as e: 2832 if self.parent.shouldRetry(tries, e, deadline): 2833 tries += 1 2834 time.sleep( 2835 self.parent.exponentialBackoff(tries, deadline)) 2836 continue 2837 raise plumbing.convert_error_to_porcelain(e) from e 2838 tries = 0 2839 for plumbing_item in plumbing_response.groups: 2840 yield plumbing.convert_group_to_porcelain(plumbing_item) 2841 if plumbing_response.meta.next_cursor == '': 2842 break 2843 req.meta.cursor = plumbing_response.meta.next_cursor 2844 2845 return generator(self, req) 2846 2847 2848class SnapshotGroups: 2849 ''' 2850 SnapshotGroups exposes the read only methods of the Groups 2851 service for historical queries. 2852 ''' 2853 def __init__(self, groups): 2854 self.groups = groups 2855 2856 def get(self, id, timeout=None): 2857 ''' 2858 Get reads one Group by ID. 2859 ''' 2860 return self.groups.get(id, timeout=timeout) 2861 2862 def list(self, filter, *args, timeout=None): 2863 ''' 2864 List gets a list of Groups matching a given set of criteria. 2865 ''' 2866 return self.groups.list(filter, *args, timeout=timeout) 2867 2868 2869class GroupsHistory: 2870 ''' 2871 GroupsHistory records all changes to the state of a Group. 2872 See `strongdm.models.GroupHistory`. 2873 ''' 2874 def __init__(self, channel, client): 2875 self.parent = client 2876 self.stub = GroupsHistoryStub(channel) 2877 2878 def list(self, filter, *args, timeout=None): 2879 ''' 2880 List gets a list of GroupHistory records matching a given set of criteria. 2881 ''' 2882 deadline = None if timeout is None else time.time() + timeout 2883 req = GroupHistoryListRequest() 2884 req.meta.CopyFrom(ListRequestMetadata()) 2885 if self.parent.page_limit > 0: 2886 req.meta.limit = self.parent.page_limit 2887 if self.parent.snapshot_datetime is not None: 2888 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2889 2890 req.filter = plumbing.quote_filter_args(filter, *args) 2891 2892 def generator(svc, req): 2893 tries = 0 2894 while True: 2895 t = None if deadline is None else deadline - time.time() 2896 try: 2897 plumbing_response = svc.stub.List( 2898 req, 2899 metadata=svc.parent.get_metadata( 2900 'GroupsHistory.List', req), 2901 timeout=t) 2902 except Exception as e: 2903 if self.parent.shouldRetry(tries, e, deadline): 2904 tries += 1 2905 time.sleep( 2906 self.parent.exponentialBackoff(tries, deadline)) 2907 continue 2908 raise plumbing.convert_error_to_porcelain(e) from e 2909 tries = 0 2910 for plumbing_item in plumbing_response.history: 2911 yield plumbing.convert_group_history_to_porcelain( 2912 plumbing_item) 2913 if plumbing_response.meta.next_cursor == '': 2914 break 2915 req.meta.cursor = plumbing_response.meta.next_cursor 2916 2917 return generator(self, req) 2918 2919 2920class GroupsRoles: 2921 ''' 2922 A GroupRole is an assignment of a Group to a Role. 2923 See `strongdm.models.GroupRole`. 2924 ''' 2925 def __init__(self, channel, client): 2926 self.parent = client 2927 self.stub = GroupsRolesStub(channel) 2928 2929 def create(self, group_role, timeout=None): 2930 ''' 2931 Create registers a new GroupRole. 2932 ''' 2933 deadline = None if timeout is None else time.time() + timeout 2934 req = GroupRoleCreateRequest() 2935 2936 if group_role is not None: 2937 req.group_role.CopyFrom( 2938 plumbing.convert_group_role_to_plumbing(group_role)) 2939 tries = 0 2940 plumbing_response = None 2941 while True: 2942 t = None if deadline is None else deadline - time.time() 2943 try: 2944 plumbing_response = self.stub.Create( 2945 req, 2946 metadata=self.parent.get_metadata('GroupsRoles.Create', 2947 req), 2948 timeout=t) 2949 except Exception as e: 2950 if self.parent.shouldRetry(tries, e, deadline): 2951 tries += 1 2952 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2953 continue 2954 raise plumbing.convert_error_to_porcelain(e) from e 2955 break 2956 2957 resp = models.GroupRoleCreateResponse() 2958 resp.group_role = plumbing.convert_group_role_to_porcelain( 2959 plumbing_response.group_role) 2960 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2961 plumbing_response.rate_limit) 2962 return resp 2963 2964 def get(self, id, timeout=None): 2965 ''' 2966 Get reads one GroupRole by ID. 2967 ''' 2968 deadline = None if timeout is None else time.time() + timeout 2969 req = GroupRoleGetRequest() 2970 if self.parent.snapshot_datetime is not None: 2971 req.meta.CopyFrom(GetRequestMetadata()) 2972 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2973 2974 req.id = (id) 2975 tries = 0 2976 plumbing_response = None 2977 while True: 2978 t = None if deadline is None else deadline - time.time() 2979 try: 2980 plumbing_response = self.stub.Get( 2981 req, 2982 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2983 timeout=t) 2984 except Exception as e: 2985 if self.parent.shouldRetry(tries, e, deadline): 2986 tries += 1 2987 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2988 continue 2989 raise plumbing.convert_error_to_porcelain(e) from e 2990 break 2991 2992 resp = models.GroupRoleGetResponse() 2993 resp.group_role = plumbing.convert_group_role_to_porcelain( 2994 plumbing_response.group_role) 2995 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2996 plumbing_response.meta) 2997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2998 plumbing_response.rate_limit) 2999 return resp 3000 3001 def delete(self, id, timeout=None): 3002 ''' 3003 Delete removes a GroupRole by ID. 3004 ''' 3005 deadline = None if timeout is None else time.time() + timeout 3006 req = GroupRoleDeleteRequest() 3007 3008 req.id = (id) 3009 tries = 0 3010 plumbing_response = None 3011 while True: 3012 t = None if deadline is None else deadline - time.time() 3013 try: 3014 plumbing_response = self.stub.Delete( 3015 req, 3016 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3017 req), 3018 timeout=t) 3019 except Exception as e: 3020 if self.parent.shouldRetry(tries, e, deadline): 3021 tries += 1 3022 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3023 continue 3024 raise plumbing.convert_error_to_porcelain(e) from e 3025 break 3026 3027 resp = models.GroupRoleDeleteResponse() 3028 resp.group_role = plumbing.convert_group_role_to_porcelain( 3029 plumbing_response.group_role) 3030 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3031 plumbing_response.meta) 3032 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3033 plumbing_response.rate_limit) 3034 return resp 3035 3036 def list(self, filter, *args, timeout=None): 3037 ''' 3038 List gets a list of GroupRoles matching a given set of criteria. 3039 ''' 3040 deadline = None if timeout is None else time.time() + timeout 3041 req = GroupRoleListRequest() 3042 req.meta.CopyFrom(ListRequestMetadata()) 3043 if self.parent.page_limit > 0: 3044 req.meta.limit = self.parent.page_limit 3045 if self.parent.snapshot_datetime is not None: 3046 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3047 3048 req.filter = plumbing.quote_filter_args(filter, *args) 3049 3050 def generator(svc, req): 3051 tries = 0 3052 while True: 3053 t = None if deadline is None else deadline - time.time() 3054 try: 3055 plumbing_response = svc.stub.List( 3056 req, 3057 metadata=svc.parent.get_metadata( 3058 'GroupsRoles.List', req), 3059 timeout=t) 3060 except Exception as e: 3061 if self.parent.shouldRetry(tries, e, deadline): 3062 tries += 1 3063 time.sleep( 3064 self.parent.exponentialBackoff(tries, deadline)) 3065 continue 3066 raise plumbing.convert_error_to_porcelain(e) from e 3067 tries = 0 3068 for plumbing_item in plumbing_response.groups_roles: 3069 yield plumbing.convert_group_role_to_porcelain( 3070 plumbing_item) 3071 if plumbing_response.meta.next_cursor == '': 3072 break 3073 req.meta.cursor = plumbing_response.meta.next_cursor 3074 3075 return generator(self, req) 3076 3077 3078class SnapshotGroupsRoles: 3079 ''' 3080 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3081 service for historical queries. 3082 ''' 3083 def __init__(self, groups_roles): 3084 self.groups_roles = groups_roles 3085 3086 def get(self, id, timeout=None): 3087 ''' 3088 Get reads one GroupRole by ID. 3089 ''' 3090 return self.groups_roles.get(id, timeout=timeout) 3091 3092 def list(self, filter, *args, timeout=None): 3093 ''' 3094 List gets a list of GroupRoles matching a given set of criteria. 3095 ''' 3096 return self.groups_roles.list(filter, *args, timeout=timeout) 3097 3098 3099class GroupsRolesHistory: 3100 ''' 3101 GroupsRolesHistory records all changes to the state of a GroupRole. 3102 See `strongdm.models.GroupRoleHistory`. 3103 ''' 3104 def __init__(self, channel, client): 3105 self.parent = client 3106 self.stub = GroupsRolesHistoryStub(channel) 3107 3108 def list(self, filter, *args, timeout=None): 3109 ''' 3110 List gets a list of GroupRoleHistory records matching a given set of criteria. 3111 ''' 3112 deadline = None if timeout is None else time.time() + timeout 3113 req = GroupRoleHistoryListRequest() 3114 req.meta.CopyFrom(ListRequestMetadata()) 3115 if self.parent.page_limit > 0: 3116 req.meta.limit = self.parent.page_limit 3117 if self.parent.snapshot_datetime is not None: 3118 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3119 3120 req.filter = plumbing.quote_filter_args(filter, *args) 3121 3122 def generator(svc, req): 3123 tries = 0 3124 while True: 3125 t = None if deadline is None else deadline - time.time() 3126 try: 3127 plumbing_response = svc.stub.List( 3128 req, 3129 metadata=svc.parent.get_metadata( 3130 'GroupsRolesHistory.List', req), 3131 timeout=t) 3132 except Exception as e: 3133 if self.parent.shouldRetry(tries, e, deadline): 3134 tries += 1 3135 time.sleep( 3136 self.parent.exponentialBackoff(tries, deadline)) 3137 continue 3138 raise plumbing.convert_error_to_porcelain(e) from e 3139 tries = 0 3140 for plumbing_item in plumbing_response.history: 3141 yield plumbing.convert_group_role_history_to_porcelain( 3142 plumbing_item) 3143 if plumbing_response.meta.next_cursor == '': 3144 break 3145 req.meta.cursor = plumbing_response.meta.next_cursor 3146 3147 return generator(self, req) 3148 3149 3150class HealthChecks: 3151 ''' 3152 HealthChecks lists the last healthcheck between each node and resource. 3153 Note the unconventional capitalization here is to prevent having a collision with GRPC 3154 See `strongdm.models.Healthcheck`. 3155 ''' 3156 def __init__(self, channel, client): 3157 self.parent = client 3158 self.stub = HealthChecksStub(channel) 3159 3160 def list(self, filter, *args, timeout=None): 3161 ''' 3162 List gets a list of Healthchecks matching a given set of criteria. 3163 ''' 3164 deadline = None if timeout is None else time.time() + timeout 3165 req = HealthcheckListRequest() 3166 req.meta.CopyFrom(ListRequestMetadata()) 3167 if self.parent.page_limit > 0: 3168 req.meta.limit = self.parent.page_limit 3169 if self.parent.snapshot_datetime is not None: 3170 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3171 3172 req.filter = plumbing.quote_filter_args(filter, *args) 3173 3174 def generator(svc, req): 3175 tries = 0 3176 while True: 3177 t = None if deadline is None else deadline - time.time() 3178 try: 3179 plumbing_response = svc.stub.List( 3180 req, 3181 metadata=svc.parent.get_metadata( 3182 'HealthChecks.List', req), 3183 timeout=t) 3184 except Exception as e: 3185 if self.parent.shouldRetry(tries, e, deadline): 3186 tries += 1 3187 time.sleep( 3188 self.parent.exponentialBackoff(tries, deadline)) 3189 continue 3190 raise plumbing.convert_error_to_porcelain(e) from e 3191 tries = 0 3192 for plumbing_item in plumbing_response.healthchecks: 3193 yield plumbing.convert_healthcheck_to_porcelain( 3194 plumbing_item) 3195 if plumbing_response.meta.next_cursor == '': 3196 break 3197 req.meta.cursor = plumbing_response.meta.next_cursor 3198 3199 return generator(self, req) 3200 3201 3202class IdentityAliases: 3203 ''' 3204 IdentityAliases assign an alias to an account within an IdentitySet. 3205 The alias is used as the username when connecting to a identity supported resource. 3206 See `strongdm.models.IdentityAlias`. 3207 ''' 3208 def __init__(self, channel, client): 3209 self.parent = client 3210 self.stub = IdentityAliasesStub(channel) 3211 3212 def create(self, identity_alias, timeout=None): 3213 ''' 3214 Create registers a new IdentityAlias. 3215 ''' 3216 deadline = None if timeout is None else time.time() + timeout 3217 req = IdentityAliasCreateRequest() 3218 3219 if identity_alias is not None: 3220 req.identity_alias.CopyFrom( 3221 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3222 tries = 0 3223 plumbing_response = None 3224 while True: 3225 t = None if deadline is None else deadline - time.time() 3226 try: 3227 plumbing_response = self.stub.Create( 3228 req, 3229 metadata=self.parent.get_metadata('IdentityAliases.Create', 3230 req), 3231 timeout=t) 3232 except Exception as e: 3233 if self.parent.shouldRetry(tries, e, deadline): 3234 tries += 1 3235 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3236 continue 3237 raise plumbing.convert_error_to_porcelain(e) from e 3238 break 3239 3240 resp = models.IdentityAliasCreateResponse() 3241 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3242 plumbing_response.identity_alias) 3243 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3244 plumbing_response.meta) 3245 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3246 plumbing_response.rate_limit) 3247 return resp 3248 3249 def get(self, id, timeout=None): 3250 ''' 3251 Get reads one IdentityAlias by ID. 3252 ''' 3253 deadline = None if timeout is None else time.time() + timeout 3254 req = IdentityAliasGetRequest() 3255 if self.parent.snapshot_datetime is not None: 3256 req.meta.CopyFrom(GetRequestMetadata()) 3257 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3258 3259 req.id = (id) 3260 tries = 0 3261 plumbing_response = None 3262 while True: 3263 t = None if deadline is None else deadline - time.time() 3264 try: 3265 plumbing_response = self.stub.Get( 3266 req, 3267 metadata=self.parent.get_metadata('IdentityAliases.Get', 3268 req), 3269 timeout=t) 3270 except Exception as e: 3271 if self.parent.shouldRetry(tries, e, deadline): 3272 tries += 1 3273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3274 continue 3275 raise plumbing.convert_error_to_porcelain(e) from e 3276 break 3277 3278 resp = models.IdentityAliasGetResponse() 3279 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3280 plumbing_response.identity_alias) 3281 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3282 plumbing_response.meta) 3283 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3284 plumbing_response.rate_limit) 3285 return resp 3286 3287 def update(self, identity_alias, timeout=None): 3288 ''' 3289 Update replaces all the fields of a IdentityAlias by ID. 3290 ''' 3291 deadline = None if timeout is None else time.time() + timeout 3292 req = IdentityAliasUpdateRequest() 3293 3294 if identity_alias is not None: 3295 req.identity_alias.CopyFrom( 3296 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3297 tries = 0 3298 plumbing_response = None 3299 while True: 3300 t = None if deadline is None else deadline - time.time() 3301 try: 3302 plumbing_response = self.stub.Update( 3303 req, 3304 metadata=self.parent.get_metadata('IdentityAliases.Update', 3305 req), 3306 timeout=t) 3307 except Exception as e: 3308 if self.parent.shouldRetry(tries, e, deadline): 3309 tries += 1 3310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3311 continue 3312 raise plumbing.convert_error_to_porcelain(e) from e 3313 break 3314 3315 resp = models.IdentityAliasUpdateResponse() 3316 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3317 plumbing_response.identity_alias) 3318 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3319 plumbing_response.meta) 3320 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3321 plumbing_response.rate_limit) 3322 return resp 3323 3324 def delete(self, id, timeout=None): 3325 ''' 3326 Delete removes a IdentityAlias by ID. 3327 ''' 3328 deadline = None if timeout is None else time.time() + timeout 3329 req = IdentityAliasDeleteRequest() 3330 3331 req.id = (id) 3332 tries = 0 3333 plumbing_response = None 3334 while True: 3335 t = None if deadline is None else deadline - time.time() 3336 try: 3337 plumbing_response = self.stub.Delete( 3338 req, 3339 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3340 req), 3341 timeout=t) 3342 except Exception as e: 3343 if self.parent.shouldRetry(tries, e, deadline): 3344 tries += 1 3345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3346 continue 3347 raise plumbing.convert_error_to_porcelain(e) from e 3348 break 3349 3350 resp = models.IdentityAliasDeleteResponse() 3351 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3352 plumbing_response.meta) 3353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3354 plumbing_response.rate_limit) 3355 return resp 3356 3357 def list(self, filter, *args, timeout=None): 3358 ''' 3359 List gets a list of IdentityAliases matching a given set of criteria. 3360 ''' 3361 deadline = None if timeout is None else time.time() + timeout 3362 req = IdentityAliasListRequest() 3363 req.meta.CopyFrom(ListRequestMetadata()) 3364 if self.parent.page_limit > 0: 3365 req.meta.limit = self.parent.page_limit 3366 if self.parent.snapshot_datetime is not None: 3367 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3368 3369 req.filter = plumbing.quote_filter_args(filter, *args) 3370 3371 def generator(svc, req): 3372 tries = 0 3373 while True: 3374 t = None if deadline is None else deadline - time.time() 3375 try: 3376 plumbing_response = svc.stub.List( 3377 req, 3378 metadata=svc.parent.get_metadata( 3379 'IdentityAliases.List', req), 3380 timeout=t) 3381 except Exception as e: 3382 if self.parent.shouldRetry(tries, e, deadline): 3383 tries += 1 3384 time.sleep( 3385 self.parent.exponentialBackoff(tries, deadline)) 3386 continue 3387 raise plumbing.convert_error_to_porcelain(e) from e 3388 tries = 0 3389 for plumbing_item in plumbing_response.identity_aliases: 3390 yield plumbing.convert_identity_alias_to_porcelain( 3391 plumbing_item) 3392 if plumbing_response.meta.next_cursor == '': 3393 break 3394 req.meta.cursor = plumbing_response.meta.next_cursor 3395 3396 return generator(self, req) 3397 3398 3399class SnapshotIdentityAliases: 3400 ''' 3401 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3402 service for historical queries. 3403 ''' 3404 def __init__(self, identity_aliases): 3405 self.identity_aliases = identity_aliases 3406 3407 def get(self, id, timeout=None): 3408 ''' 3409 Get reads one IdentityAlias by ID. 3410 ''' 3411 return self.identity_aliases.get(id, timeout=timeout) 3412 3413 def list(self, filter, *args, timeout=None): 3414 ''' 3415 List gets a list of IdentityAliases matching a given set of criteria. 3416 ''' 3417 return self.identity_aliases.list(filter, *args, timeout=timeout) 3418 3419 3420class IdentityAliasesHistory: 3421 ''' 3422 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3423 See `strongdm.models.IdentityAliasHistory`. 3424 ''' 3425 def __init__(self, channel, client): 3426 self.parent = client 3427 self.stub = IdentityAliasesHistoryStub(channel) 3428 3429 def list(self, filter, *args, timeout=None): 3430 ''' 3431 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3432 ''' 3433 deadline = None if timeout is None else time.time() + timeout 3434 req = IdentityAliasHistoryListRequest() 3435 req.meta.CopyFrom(ListRequestMetadata()) 3436 if self.parent.page_limit > 0: 3437 req.meta.limit = self.parent.page_limit 3438 if self.parent.snapshot_datetime is not None: 3439 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3440 3441 req.filter = plumbing.quote_filter_args(filter, *args) 3442 3443 def generator(svc, req): 3444 tries = 0 3445 while True: 3446 t = None if deadline is None else deadline - time.time() 3447 try: 3448 plumbing_response = svc.stub.List( 3449 req, 3450 metadata=svc.parent.get_metadata( 3451 'IdentityAliasesHistory.List', req), 3452 timeout=t) 3453 except Exception as e: 3454 if self.parent.shouldRetry(tries, e, deadline): 3455 tries += 1 3456 time.sleep( 3457 self.parent.exponentialBackoff(tries, deadline)) 3458 continue 3459 raise plumbing.convert_error_to_porcelain(e) from e 3460 tries = 0 3461 for plumbing_item in plumbing_response.history: 3462 yield plumbing.convert_identity_alias_history_to_porcelain( 3463 plumbing_item) 3464 if plumbing_response.meta.next_cursor == '': 3465 break 3466 req.meta.cursor = plumbing_response.meta.next_cursor 3467 3468 return generator(self, req) 3469 3470 3471class IdentitySets: 3472 ''' 3473 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3474 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3475 See `strongdm.models.IdentitySet`. 3476 ''' 3477 def __init__(self, channel, client): 3478 self.parent = client 3479 self.stub = IdentitySetsStub(channel) 3480 3481 def create(self, identity_set, timeout=None): 3482 ''' 3483 Create registers a new IdentitySet. 3484 ''' 3485 deadline = None if timeout is None else time.time() + timeout 3486 req = IdentitySetCreateRequest() 3487 3488 if identity_set is not None: 3489 req.identity_set.CopyFrom( 3490 plumbing.convert_identity_set_to_plumbing(identity_set)) 3491 tries = 0 3492 plumbing_response = None 3493 while True: 3494 t = None if deadline is None else deadline - time.time() 3495 try: 3496 plumbing_response = self.stub.Create( 3497 req, 3498 metadata=self.parent.get_metadata('IdentitySets.Create', 3499 req), 3500 timeout=t) 3501 except Exception as e: 3502 if self.parent.shouldRetry(tries, e, deadline): 3503 tries += 1 3504 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3505 continue 3506 raise plumbing.convert_error_to_porcelain(e) from e 3507 break 3508 3509 resp = models.IdentitySetCreateResponse() 3510 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3511 plumbing_response.identity_set) 3512 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3513 plumbing_response.meta) 3514 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3515 plumbing_response.rate_limit) 3516 return resp 3517 3518 def get(self, id, timeout=None): 3519 ''' 3520 Get reads one IdentitySet by ID. 3521 ''' 3522 deadline = None if timeout is None else time.time() + timeout 3523 req = IdentitySetGetRequest() 3524 if self.parent.snapshot_datetime is not None: 3525 req.meta.CopyFrom(GetRequestMetadata()) 3526 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3527 3528 req.id = (id) 3529 tries = 0 3530 plumbing_response = None 3531 while True: 3532 t = None if deadline is None else deadline - time.time() 3533 try: 3534 plumbing_response = self.stub.Get( 3535 req, 3536 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3537 timeout=t) 3538 except Exception as e: 3539 if self.parent.shouldRetry(tries, e, deadline): 3540 tries += 1 3541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3542 continue 3543 raise plumbing.convert_error_to_porcelain(e) from e 3544 break 3545 3546 resp = models.IdentitySetGetResponse() 3547 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3548 plumbing_response.identity_set) 3549 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3550 plumbing_response.meta) 3551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3552 plumbing_response.rate_limit) 3553 return resp 3554 3555 def update(self, identity_set, timeout=None): 3556 ''' 3557 Update replaces all the fields of a IdentitySet by ID. 3558 ''' 3559 deadline = None if timeout is None else time.time() + timeout 3560 req = IdentitySetUpdateRequest() 3561 3562 if identity_set is not None: 3563 req.identity_set.CopyFrom( 3564 plumbing.convert_identity_set_to_plumbing(identity_set)) 3565 tries = 0 3566 plumbing_response = None 3567 while True: 3568 t = None if deadline is None else deadline - time.time() 3569 try: 3570 plumbing_response = self.stub.Update( 3571 req, 3572 metadata=self.parent.get_metadata('IdentitySets.Update', 3573 req), 3574 timeout=t) 3575 except Exception as e: 3576 if self.parent.shouldRetry(tries, e, deadline): 3577 tries += 1 3578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3579 continue 3580 raise plumbing.convert_error_to_porcelain(e) from e 3581 break 3582 3583 resp = models.IdentitySetUpdateResponse() 3584 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3585 plumbing_response.identity_set) 3586 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3587 plumbing_response.meta) 3588 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3589 plumbing_response.rate_limit) 3590 return resp 3591 3592 def delete(self, id, timeout=None): 3593 ''' 3594 Delete removes a IdentitySet by ID. 3595 ''' 3596 deadline = None if timeout is None else time.time() + timeout 3597 req = IdentitySetDeleteRequest() 3598 3599 req.id = (id) 3600 tries = 0 3601 plumbing_response = None 3602 while True: 3603 t = None if deadline is None else deadline - time.time() 3604 try: 3605 plumbing_response = self.stub.Delete( 3606 req, 3607 metadata=self.parent.get_metadata('IdentitySets.Delete', 3608 req), 3609 timeout=t) 3610 except Exception as e: 3611 if self.parent.shouldRetry(tries, e, deadline): 3612 tries += 1 3613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3614 continue 3615 raise plumbing.convert_error_to_porcelain(e) from e 3616 break 3617 3618 resp = models.IdentitySetDeleteResponse() 3619 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3620 plumbing_response.meta) 3621 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3622 plumbing_response.rate_limit) 3623 return resp 3624 3625 def list(self, filter, *args, timeout=None): 3626 ''' 3627 List gets a list of IdentitySets matching a given set of criteria. 3628 ''' 3629 deadline = None if timeout is None else time.time() + timeout 3630 req = IdentitySetListRequest() 3631 req.meta.CopyFrom(ListRequestMetadata()) 3632 if self.parent.page_limit > 0: 3633 req.meta.limit = self.parent.page_limit 3634 if self.parent.snapshot_datetime is not None: 3635 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3636 3637 req.filter = plumbing.quote_filter_args(filter, *args) 3638 3639 def generator(svc, req): 3640 tries = 0 3641 while True: 3642 t = None if deadline is None else deadline - time.time() 3643 try: 3644 plumbing_response = svc.stub.List( 3645 req, 3646 metadata=svc.parent.get_metadata( 3647 'IdentitySets.List', req), 3648 timeout=t) 3649 except Exception as e: 3650 if self.parent.shouldRetry(tries, e, deadline): 3651 tries += 1 3652 time.sleep( 3653 self.parent.exponentialBackoff(tries, deadline)) 3654 continue 3655 raise plumbing.convert_error_to_porcelain(e) from e 3656 tries = 0 3657 for plumbing_item in plumbing_response.identity_sets: 3658 yield plumbing.convert_identity_set_to_porcelain( 3659 plumbing_item) 3660 if plumbing_response.meta.next_cursor == '': 3661 break 3662 req.meta.cursor = plumbing_response.meta.next_cursor 3663 3664 return generator(self, req) 3665 3666 3667class SnapshotIdentitySets: 3668 ''' 3669 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3670 service for historical queries. 3671 ''' 3672 def __init__(self, identity_sets): 3673 self.identity_sets = identity_sets 3674 3675 def get(self, id, timeout=None): 3676 ''' 3677 Get reads one IdentitySet by ID. 3678 ''' 3679 return self.identity_sets.get(id, timeout=timeout) 3680 3681 def list(self, filter, *args, timeout=None): 3682 ''' 3683 List gets a list of IdentitySets matching a given set of criteria. 3684 ''' 3685 return self.identity_sets.list(filter, *args, timeout=timeout) 3686 3687 3688class IdentitySetsHistory: 3689 ''' 3690 IdentitySetsHistory records all changes to the state of a IdentitySet. 3691 See `strongdm.models.IdentitySetHistory`. 3692 ''' 3693 def __init__(self, channel, client): 3694 self.parent = client 3695 self.stub = IdentitySetsHistoryStub(channel) 3696 3697 def list(self, filter, *args, timeout=None): 3698 ''' 3699 List gets a list of IdentitySetHistory records matching a given set of criteria. 3700 ''' 3701 deadline = None if timeout is None else time.time() + timeout 3702 req = IdentitySetHistoryListRequest() 3703 req.meta.CopyFrom(ListRequestMetadata()) 3704 if self.parent.page_limit > 0: 3705 req.meta.limit = self.parent.page_limit 3706 if self.parent.snapshot_datetime is not None: 3707 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3708 3709 req.filter = plumbing.quote_filter_args(filter, *args) 3710 3711 def generator(svc, req): 3712 tries = 0 3713 while True: 3714 t = None if deadline is None else deadline - time.time() 3715 try: 3716 plumbing_response = svc.stub.List( 3717 req, 3718 metadata=svc.parent.get_metadata( 3719 'IdentitySetsHistory.List', req), 3720 timeout=t) 3721 except Exception as e: 3722 if self.parent.shouldRetry(tries, e, deadline): 3723 tries += 1 3724 time.sleep( 3725 self.parent.exponentialBackoff(tries, deadline)) 3726 continue 3727 raise plumbing.convert_error_to_porcelain(e) from e 3728 tries = 0 3729 for plumbing_item in plumbing_response.history: 3730 yield plumbing.convert_identity_set_history_to_porcelain( 3731 plumbing_item) 3732 if plumbing_response.meta.next_cursor == '': 3733 break 3734 req.meta.cursor = plumbing_response.meta.next_cursor 3735 3736 return generator(self, req) 3737 3738 3739class ManagedSecrets: 3740 ''' 3741 ManagedSecret is a private vertical for creating, reading, updating, 3742 deleting, listing and rotating the managed secrets in the secrets engines as 3743 an authenticated user. 3744 See `strongdm.models.ManagedSecret`. 3745 ''' 3746 def __init__(self, channel, client): 3747 self.parent = client 3748 self.stub = ManagedSecretsStub(channel) 3749 3750 def list(self, filter, *args, timeout=None): 3751 ''' 3752 List returns Managed Secrets from a Secret Engine. 3753 ''' 3754 deadline = None if timeout is None else time.time() + timeout 3755 req = ManagedSecretListRequest() 3756 req.meta.CopyFrom(ListRequestMetadata()) 3757 if self.parent.page_limit > 0: 3758 req.meta.limit = self.parent.page_limit 3759 if self.parent.snapshot_datetime is not None: 3760 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3761 3762 req.filter = plumbing.quote_filter_args(filter, *args) 3763 3764 def generator(svc, req): 3765 tries = 0 3766 while True: 3767 t = None if deadline is None else deadline - time.time() 3768 try: 3769 plumbing_response = svc.stub.List( 3770 req, 3771 metadata=svc.parent.get_metadata( 3772 'ManagedSecrets.List', req), 3773 timeout=t) 3774 except Exception as e: 3775 if self.parent.shouldRetry(tries, e, deadline): 3776 tries += 1 3777 time.sleep( 3778 self.parent.exponentialBackoff(tries, deadline)) 3779 continue 3780 raise plumbing.convert_error_to_porcelain(e) from e 3781 tries = 0 3782 for plumbing_item in plumbing_response.managed_secrets: 3783 yield plumbing.convert_managed_secret_to_porcelain( 3784 plumbing_item) 3785 if plumbing_response.meta.next_cursor == '': 3786 break 3787 req.meta.cursor = plumbing_response.meta.next_cursor 3788 3789 return generator(self, req) 3790 3791 def list_by_actor(self, filter, *args, timeout=None): 3792 ''' 3793 List returns Managed Secrets for an Actor from a Secret Engine. 3794 ''' 3795 deadline = None if timeout is None else time.time() + timeout 3796 req = ManagedSecretListRequest() 3797 req.meta.CopyFrom(ListRequestMetadata()) 3798 if self.parent.page_limit > 0: 3799 req.meta.limit = self.parent.page_limit 3800 if self.parent.snapshot_datetime is not None: 3801 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3802 3803 req.filter = plumbing.quote_filter_args(filter, *args) 3804 3805 def generator(svc, req): 3806 tries = 0 3807 while True: 3808 t = None if deadline is None else deadline - time.time() 3809 try: 3810 plumbing_response = svc.stub.ListByActor( 3811 req, 3812 metadata=svc.parent.get_metadata( 3813 'ManagedSecrets.ListByActor', req), 3814 timeout=t) 3815 except Exception as e: 3816 if self.parent.shouldRetry(tries, e, deadline): 3817 tries += 1 3818 time.sleep( 3819 self.parent.exponentialBackoff(tries, deadline)) 3820 continue 3821 raise plumbing.convert_error_to_porcelain(e) from e 3822 tries = 0 3823 for plumbing_item in plumbing_response.managed_secrets: 3824 yield plumbing.convert_managed_secret_to_porcelain( 3825 plumbing_item) 3826 if plumbing_response.meta.next_cursor == '': 3827 break 3828 req.meta.cursor = plumbing_response.meta.next_cursor 3829 3830 return generator(self, req) 3831 3832 def create(self, managed_secret, timeout=None): 3833 ''' 3834 Create creates a Managed Secret 3835 ''' 3836 deadline = None if timeout is None else time.time() + timeout 3837 req = ManagedSecretCreateRequest() 3838 3839 if managed_secret is not None: 3840 req.managed_secret.CopyFrom( 3841 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3842 tries = 0 3843 plumbing_response = None 3844 while True: 3845 t = None if deadline is None else deadline - time.time() 3846 try: 3847 plumbing_response = self.stub.Create( 3848 req, 3849 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3850 req), 3851 timeout=t) 3852 except Exception as e: 3853 if self.parent.shouldRetry(tries, e, deadline): 3854 tries += 1 3855 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3856 continue 3857 raise plumbing.convert_error_to_porcelain(e) from e 3858 break 3859 3860 resp = models.ManagedSecretCreateResponse() 3861 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3862 plumbing_response.managed_secret) 3863 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3864 plumbing_response.meta) 3865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3866 plumbing_response.rate_limit) 3867 return resp 3868 3869 def update(self, managed_secret, timeout=None): 3870 ''' 3871 Update updates a Managed Secret 3872 ''' 3873 deadline = None if timeout is None else time.time() + timeout 3874 req = ManagedSecretUpdateRequest() 3875 3876 if managed_secret is not None: 3877 req.managed_secret.CopyFrom( 3878 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3879 tries = 0 3880 plumbing_response = None 3881 while True: 3882 t = None if deadline is None else deadline - time.time() 3883 try: 3884 plumbing_response = self.stub.Update( 3885 req, 3886 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3887 req), 3888 timeout=t) 3889 except Exception as e: 3890 if self.parent.shouldRetry(tries, e, deadline): 3891 tries += 1 3892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3893 continue 3894 raise plumbing.convert_error_to_porcelain(e) from e 3895 break 3896 3897 resp = models.ManagedSecretUpdateResponse() 3898 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3899 plumbing_response.managed_secret) 3900 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3901 plumbing_response.meta) 3902 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3903 plumbing_response.rate_limit) 3904 return resp 3905 3906 def rotate(self, id, timeout=None): 3907 ''' 3908 Rotate forces rotation of Managed Secret 3909 ''' 3910 deadline = None if timeout is None else time.time() + timeout 3911 req = ManagedSecretRotateRequest() 3912 3913 req.id = (id) 3914 tries = 0 3915 plumbing_response = None 3916 while True: 3917 t = None if deadline is None else deadline - time.time() 3918 try: 3919 plumbing_response = self.stub.Rotate( 3920 req, 3921 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3922 req), 3923 timeout=t) 3924 except Exception as e: 3925 if self.parent.shouldRetry(tries, e, deadline): 3926 tries += 1 3927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3928 continue 3929 raise plumbing.convert_error_to_porcelain(e) from e 3930 break 3931 3932 resp = models.ManagedSecretRotateResponse() 3933 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3934 plumbing_response.meta) 3935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3936 plumbing_response.rate_limit) 3937 return resp 3938 3939 def delete(self, id, timeout=None): 3940 ''' 3941 Delete deletes a Managed Secret 3942 ''' 3943 deadline = None if timeout is None else time.time() + timeout 3944 req = ManagedSecretDeleteRequest() 3945 3946 req.id = (id) 3947 tries = 0 3948 plumbing_response = None 3949 while True: 3950 t = None if deadline is None else deadline - time.time() 3951 try: 3952 plumbing_response = self.stub.Delete( 3953 req, 3954 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3955 req), 3956 timeout=t) 3957 except Exception as e: 3958 if self.parent.shouldRetry(tries, e, deadline): 3959 tries += 1 3960 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3961 continue 3962 raise plumbing.convert_error_to_porcelain(e) from e 3963 break 3964 3965 resp = models.ManagedSecretDeleteResponse() 3966 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3967 plumbing_response.rate_limit) 3968 return resp 3969 3970 def force_delete(self, id, timeout=None): 3971 ''' 3972 ForceDelete deletes a Managed Secret regardless of errors on external system 3973 ''' 3974 deadline = None if timeout is None else time.time() + timeout 3975 req = ManagedSecretDeleteRequest() 3976 3977 req.id = (id) 3978 tries = 0 3979 plumbing_response = None 3980 while True: 3981 t = None if deadline is None else deadline - time.time() 3982 try: 3983 plumbing_response = self.stub.ForceDelete( 3984 req, 3985 metadata=self.parent.get_metadata( 3986 'ManagedSecrets.ForceDelete', req), 3987 timeout=t) 3988 except Exception as e: 3989 if self.parent.shouldRetry(tries, e, deadline): 3990 tries += 1 3991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3992 continue 3993 raise plumbing.convert_error_to_porcelain(e) from e 3994 break 3995 3996 resp = models.ManagedSecretDeleteResponse() 3997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3998 plumbing_response.rate_limit) 3999 return resp 4000 4001 def get(self, id, timeout=None): 4002 ''' 4003 Get gets details of a Managed Secret without sensitive data 4004 ''' 4005 deadline = None if timeout is None else time.time() + timeout 4006 req = ManagedSecretGetRequest() 4007 if self.parent.snapshot_datetime is not None: 4008 req.meta.CopyFrom(GetRequestMetadata()) 4009 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4010 4011 req.id = (id) 4012 tries = 0 4013 plumbing_response = None 4014 while True: 4015 t = None if deadline is None else deadline - time.time() 4016 try: 4017 plumbing_response = self.stub.Get( 4018 req, 4019 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4020 req), 4021 timeout=t) 4022 except Exception as e: 4023 if self.parent.shouldRetry(tries, e, deadline): 4024 tries += 1 4025 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4026 continue 4027 raise plumbing.convert_error_to_porcelain(e) from e 4028 break 4029 4030 resp = models.ManagedSecretGetResponse() 4031 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4032 plumbing_response.managed_secret) 4033 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4034 plumbing_response.meta) 4035 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4036 plumbing_response.rate_limit) 4037 return resp 4038 4039 def retrieve(self, id, public_key, timeout=None): 4040 ''' 4041 Retrieve returns Managed Secret with sensitive data 4042 ''' 4043 deadline = None if timeout is None else time.time() + timeout 4044 req = ManagedSecretRetrieveRequest() 4045 4046 req.id = (id) 4047 req.public_key = (public_key) 4048 tries = 0 4049 plumbing_response = None 4050 while True: 4051 t = None if deadline is None else deadline - time.time() 4052 try: 4053 plumbing_response = self.stub.Retrieve( 4054 req, 4055 metadata=self.parent.get_metadata( 4056 'ManagedSecrets.Retrieve', req), 4057 timeout=t) 4058 except Exception as e: 4059 if self.parent.shouldRetry(tries, e, deadline): 4060 tries += 1 4061 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4062 continue 4063 raise plumbing.convert_error_to_porcelain(e) from e 4064 break 4065 4066 resp = models.ManagedSecretRetrieveResponse() 4067 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4068 plumbing_response.managed_secret) 4069 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4070 plumbing_response.meta) 4071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4072 plumbing_response.rate_limit) 4073 return resp 4074 4075 def validate(self, id, timeout=None): 4076 ''' 4077 Validate returns the result of testing the stored credential against the 4078 secret engine. 4079 ''' 4080 deadline = None if timeout is None else time.time() + timeout 4081 req = ManagedSecretValidateRequest() 4082 4083 req.id = (id) 4084 tries = 0 4085 plumbing_response = None 4086 while True: 4087 t = None if deadline is None else deadline - time.time() 4088 try: 4089 plumbing_response = self.stub.Validate( 4090 req, 4091 metadata=self.parent.get_metadata( 4092 'ManagedSecrets.Validate', req), 4093 timeout=t) 4094 except Exception as e: 4095 if self.parent.shouldRetry(tries, e, deadline): 4096 tries += 1 4097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4098 continue 4099 raise plumbing.convert_error_to_porcelain(e) from e 4100 break 4101 4102 resp = models.ManagedSecretValidateResponse() 4103 resp.invalid_info = (plumbing_response.invalid_info) 4104 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4105 plumbing_response.meta) 4106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4107 plumbing_response.rate_limit) 4108 resp.valid = (plumbing_response.valid) 4109 return resp 4110 4111 def logs(self, filter, *args, timeout=None): 4112 ''' 4113 Logs returns the audit records for the managed secret. This may be replaced 4114 in the future. 4115 ''' 4116 deadline = None if timeout is None else time.time() + timeout 4117 req = ManagedSecretLogsRequest() 4118 req.meta.CopyFrom(ListRequestMetadata()) 4119 if self.parent.page_limit > 0: 4120 req.meta.limit = self.parent.page_limit 4121 if self.parent.snapshot_datetime is not None: 4122 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4123 4124 req.filter = plumbing.quote_filter_args(filter, *args) 4125 4126 def generator(svc, req): 4127 tries = 0 4128 while True: 4129 t = None if deadline is None else deadline - time.time() 4130 try: 4131 plumbing_response = svc.stub.Logs( 4132 req, 4133 metadata=svc.parent.get_metadata( 4134 'ManagedSecrets.Logs', req), 4135 timeout=t) 4136 except Exception as e: 4137 if self.parent.shouldRetry(tries, e, deadline): 4138 tries += 1 4139 time.sleep( 4140 self.parent.exponentialBackoff(tries, deadline)) 4141 continue 4142 raise plumbing.convert_error_to_porcelain(e) from e 4143 tries = 0 4144 for plumbing_item in plumbing_response.managed_secret_logs: 4145 yield plumbing.convert_managed_secret_log_to_porcelain( 4146 plumbing_item) 4147 if plumbing_response.meta.next_cursor == '': 4148 break 4149 req.meta.cursor = plumbing_response.meta.next_cursor 4150 4151 return generator(self, req) 4152 4153 4154class Nodes: 4155 ''' 4156 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 4157 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 4158 - **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. 4159 See: 4160 `strongdm.models.Gateway` 4161 `strongdm.models.ProxyCluster` 4162 `strongdm.models.Relay` 4163 ''' 4164 def __init__(self, channel, client): 4165 self.parent = client 4166 self.stub = NodesStub(channel) 4167 4168 def create(self, node, timeout=None): 4169 ''' 4170 Create registers a new Node. 4171 ''' 4172 deadline = None if timeout is None else time.time() + timeout 4173 req = NodeCreateRequest() 4174 4175 if node is not None: 4176 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4177 tries = 0 4178 plumbing_response = None 4179 while True: 4180 t = None if deadline is None else deadline - time.time() 4181 try: 4182 plumbing_response = self.stub.Create( 4183 req, 4184 metadata=self.parent.get_metadata('Nodes.Create', req), 4185 timeout=t) 4186 except Exception as e: 4187 if self.parent.shouldRetry(tries, e, deadline): 4188 tries += 1 4189 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4190 continue 4191 raise plumbing.convert_error_to_porcelain(e) from e 4192 break 4193 4194 resp = models.NodeCreateResponse() 4195 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4196 plumbing_response.meta) 4197 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4199 plumbing_response.rate_limit) 4200 resp.token = (plumbing_response.token) 4201 return resp 4202 4203 def get(self, id, timeout=None): 4204 ''' 4205 Get reads one Node by ID. 4206 ''' 4207 deadline = None if timeout is None else time.time() + timeout 4208 req = NodeGetRequest() 4209 if self.parent.snapshot_datetime is not None: 4210 req.meta.CopyFrom(GetRequestMetadata()) 4211 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4212 4213 req.id = (id) 4214 tries = 0 4215 plumbing_response = None 4216 while True: 4217 t = None if deadline is None else deadline - time.time() 4218 try: 4219 plumbing_response = self.stub.Get( 4220 req, 4221 metadata=self.parent.get_metadata('Nodes.Get', req), 4222 timeout=t) 4223 except Exception as e: 4224 if self.parent.shouldRetry(tries, e, deadline): 4225 tries += 1 4226 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4227 continue 4228 raise plumbing.convert_error_to_porcelain(e) from e 4229 break 4230 4231 resp = models.NodeGetResponse() 4232 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4233 plumbing_response.meta) 4234 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4235 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4236 plumbing_response.rate_limit) 4237 return resp 4238 4239 def update(self, node, timeout=None): 4240 ''' 4241 Update replaces all the fields of a Node by ID. 4242 ''' 4243 deadline = None if timeout is None else time.time() + timeout 4244 req = NodeUpdateRequest() 4245 4246 if node is not None: 4247 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4248 tries = 0 4249 plumbing_response = None 4250 while True: 4251 t = None if deadline is None else deadline - time.time() 4252 try: 4253 plumbing_response = self.stub.Update( 4254 req, 4255 metadata=self.parent.get_metadata('Nodes.Update', req), 4256 timeout=t) 4257 except Exception as e: 4258 if self.parent.shouldRetry(tries, e, deadline): 4259 tries += 1 4260 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4261 continue 4262 raise plumbing.convert_error_to_porcelain(e) from e 4263 break 4264 4265 resp = models.NodeUpdateResponse() 4266 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4267 plumbing_response.meta) 4268 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4270 plumbing_response.rate_limit) 4271 return resp 4272 4273 def delete(self, id, timeout=None): 4274 ''' 4275 Delete removes a Node by ID. 4276 ''' 4277 deadline = None if timeout is None else time.time() + timeout 4278 req = NodeDeleteRequest() 4279 4280 req.id = (id) 4281 tries = 0 4282 plumbing_response = None 4283 while True: 4284 t = None if deadline is None else deadline - time.time() 4285 try: 4286 plumbing_response = self.stub.Delete( 4287 req, 4288 metadata=self.parent.get_metadata('Nodes.Delete', req), 4289 timeout=t) 4290 except Exception as e: 4291 if self.parent.shouldRetry(tries, e, deadline): 4292 tries += 1 4293 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4294 continue 4295 raise plumbing.convert_error_to_porcelain(e) from e 4296 break 4297 4298 resp = models.NodeDeleteResponse() 4299 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4300 plumbing_response.meta) 4301 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4302 plumbing_response.rate_limit) 4303 return resp 4304 4305 def list(self, filter, *args, timeout=None): 4306 ''' 4307 List gets a list of Nodes matching a given set of criteria. 4308 ''' 4309 deadline = None if timeout is None else time.time() + timeout 4310 req = NodeListRequest() 4311 req.meta.CopyFrom(ListRequestMetadata()) 4312 if self.parent.page_limit > 0: 4313 req.meta.limit = self.parent.page_limit 4314 if self.parent.snapshot_datetime is not None: 4315 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4316 4317 req.filter = plumbing.quote_filter_args(filter, *args) 4318 4319 def generator(svc, req): 4320 tries = 0 4321 while True: 4322 t = None if deadline is None else deadline - time.time() 4323 try: 4324 plumbing_response = svc.stub.List( 4325 req, 4326 metadata=svc.parent.get_metadata('Nodes.List', req), 4327 timeout=t) 4328 except Exception as e: 4329 if self.parent.shouldRetry(tries, e, deadline): 4330 tries += 1 4331 time.sleep( 4332 self.parent.exponentialBackoff(tries, deadline)) 4333 continue 4334 raise plumbing.convert_error_to_porcelain(e) from e 4335 tries = 0 4336 for plumbing_item in plumbing_response.nodes: 4337 yield plumbing.convert_node_to_porcelain(plumbing_item) 4338 if plumbing_response.meta.next_cursor == '': 4339 break 4340 req.meta.cursor = plumbing_response.meta.next_cursor 4341 4342 return generator(self, req) 4343 4344 4345class SnapshotNodes: 4346 ''' 4347 SnapshotNodes exposes the read only methods of the Nodes 4348 service for historical queries. 4349 ''' 4350 def __init__(self, nodes): 4351 self.nodes = nodes 4352 4353 def get(self, id, timeout=None): 4354 ''' 4355 Get reads one Node by ID. 4356 ''' 4357 return self.nodes.get(id, timeout=timeout) 4358 4359 def list(self, filter, *args, timeout=None): 4360 ''' 4361 List gets a list of Nodes matching a given set of criteria. 4362 ''' 4363 return self.nodes.list(filter, *args, timeout=timeout) 4364 4365 4366class NodesHistory: 4367 ''' 4368 NodesHistory records all changes to the state of a Node. 4369 See `strongdm.models.NodeHistory`. 4370 ''' 4371 def __init__(self, channel, client): 4372 self.parent = client 4373 self.stub = NodesHistoryStub(channel) 4374 4375 def list(self, filter, *args, timeout=None): 4376 ''' 4377 List gets a list of NodeHistory records matching a given set of criteria. 4378 ''' 4379 deadline = None if timeout is None else time.time() + timeout 4380 req = NodeHistoryListRequest() 4381 req.meta.CopyFrom(ListRequestMetadata()) 4382 if self.parent.page_limit > 0: 4383 req.meta.limit = self.parent.page_limit 4384 if self.parent.snapshot_datetime is not None: 4385 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4386 4387 req.filter = plumbing.quote_filter_args(filter, *args) 4388 4389 def generator(svc, req): 4390 tries = 0 4391 while True: 4392 t = None if deadline is None else deadline - time.time() 4393 try: 4394 plumbing_response = svc.stub.List( 4395 req, 4396 metadata=svc.parent.get_metadata( 4397 'NodesHistory.List', req), 4398 timeout=t) 4399 except Exception as e: 4400 if self.parent.shouldRetry(tries, e, deadline): 4401 tries += 1 4402 time.sleep( 4403 self.parent.exponentialBackoff(tries, deadline)) 4404 continue 4405 raise plumbing.convert_error_to_porcelain(e) from e 4406 tries = 0 4407 for plumbing_item in plumbing_response.history: 4408 yield plumbing.convert_node_history_to_porcelain( 4409 plumbing_item) 4410 if plumbing_response.meta.next_cursor == '': 4411 break 4412 req.meta.cursor = plumbing_response.meta.next_cursor 4413 4414 return generator(self, req) 4415 4416 4417class OrganizationHistory: 4418 ''' 4419 OrganizationHistory records all changes to the state of an Organization. 4420 See `strongdm.models.OrganizationHistoryRecord`. 4421 ''' 4422 def __init__(self, channel, client): 4423 self.parent = client 4424 self.stub = OrganizationHistoryStub(channel) 4425 4426 def list(self, filter, *args, timeout=None): 4427 ''' 4428 List gets a list of OrganizationHistory records matching a given set of criteria. 4429 ''' 4430 deadline = None if timeout is None else time.time() + timeout 4431 req = OrganizationHistoryListRequest() 4432 req.meta.CopyFrom(ListRequestMetadata()) 4433 if self.parent.page_limit > 0: 4434 req.meta.limit = self.parent.page_limit 4435 if self.parent.snapshot_datetime is not None: 4436 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4437 4438 req.filter = plumbing.quote_filter_args(filter, *args) 4439 4440 def generator(svc, req): 4441 tries = 0 4442 while True: 4443 t = None if deadline is None else deadline - time.time() 4444 try: 4445 plumbing_response = svc.stub.List( 4446 req, 4447 metadata=svc.parent.get_metadata( 4448 'OrganizationHistory.List', req), 4449 timeout=t) 4450 except Exception as e: 4451 if self.parent.shouldRetry(tries, e, deadline): 4452 tries += 1 4453 time.sleep( 4454 self.parent.exponentialBackoff(tries, deadline)) 4455 continue 4456 raise plumbing.convert_error_to_porcelain(e) from e 4457 tries = 0 4458 for plumbing_item in plumbing_response.history: 4459 yield plumbing.convert_organization_history_record_to_porcelain( 4460 plumbing_item) 4461 if plumbing_response.meta.next_cursor == '': 4462 break 4463 req.meta.cursor = plumbing_response.meta.next_cursor 4464 4465 return generator(self, req) 4466 4467 4468class PeeringGroupNodes: 4469 ''' 4470 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4471 See `strongdm.models.PeeringGroupNode`. 4472 ''' 4473 def __init__(self, channel, client): 4474 self.parent = client 4475 self.stub = PeeringGroupNodesStub(channel) 4476 4477 def create(self, peering_group_node, timeout=None): 4478 ''' 4479 Create attaches a Node to a PeeringGroup 4480 ''' 4481 deadline = None if timeout is None else time.time() + timeout 4482 req = PeeringGroupNodeCreateRequest() 4483 4484 if peering_group_node is not None: 4485 req.peering_group_node.CopyFrom( 4486 plumbing.convert_peering_group_node_to_plumbing( 4487 peering_group_node)) 4488 tries = 0 4489 plumbing_response = None 4490 while True: 4491 t = None if deadline is None else deadline - time.time() 4492 try: 4493 plumbing_response = self.stub.Create( 4494 req, 4495 metadata=self.parent.get_metadata( 4496 'PeeringGroupNodes.Create', req), 4497 timeout=t) 4498 except Exception as e: 4499 if self.parent.shouldRetry(tries, e, deadline): 4500 tries += 1 4501 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4502 continue 4503 raise plumbing.convert_error_to_porcelain(e) from e 4504 break 4505 4506 resp = models.PeeringGroupNodeCreateResponse() 4507 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4508 plumbing_response.meta) 4509 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4510 plumbing_response.peering_group_node) 4511 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4512 plumbing_response.rate_limit) 4513 return resp 4514 4515 def delete(self, id, timeout=None): 4516 ''' 4517 Delete detaches a Node to a PeeringGroup. 4518 ''' 4519 deadline = None if timeout is None else time.time() + timeout 4520 req = PeeringGroupNodeDeleteRequest() 4521 4522 req.id = (id) 4523 tries = 0 4524 plumbing_response = None 4525 while True: 4526 t = None if deadline is None else deadline - time.time() 4527 try: 4528 plumbing_response = self.stub.Delete( 4529 req, 4530 metadata=self.parent.get_metadata( 4531 'PeeringGroupNodes.Delete', req), 4532 timeout=t) 4533 except Exception as e: 4534 if self.parent.shouldRetry(tries, e, deadline): 4535 tries += 1 4536 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4537 continue 4538 raise plumbing.convert_error_to_porcelain(e) from e 4539 break 4540 4541 resp = models.PeeringGroupNodeDeleteResponse() 4542 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4543 plumbing_response.meta) 4544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4545 plumbing_response.rate_limit) 4546 return resp 4547 4548 def get(self, id, timeout=None): 4549 ''' 4550 Get reads the information of one peering group to node attachment. 4551 ''' 4552 deadline = None if timeout is None else time.time() + timeout 4553 req = PeeringGroupNodeGetRequest() 4554 if self.parent.snapshot_datetime is not None: 4555 req.meta.CopyFrom(GetRequestMetadata()) 4556 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4557 4558 req.id = (id) 4559 tries = 0 4560 plumbing_response = None 4561 while True: 4562 t = None if deadline is None else deadline - time.time() 4563 try: 4564 plumbing_response = self.stub.Get( 4565 req, 4566 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4567 req), 4568 timeout=t) 4569 except Exception as e: 4570 if self.parent.shouldRetry(tries, e, deadline): 4571 tries += 1 4572 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4573 continue 4574 raise plumbing.convert_error_to_porcelain(e) from e 4575 break 4576 4577 resp = models.PeeringGroupNodeGetResponse() 4578 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4579 plumbing_response.meta) 4580 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4581 plumbing_response.peering_group_node) 4582 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4583 plumbing_response.rate_limit) 4584 return resp 4585 4586 def list(self, filter, *args, timeout=None): 4587 ''' 4588 List gets a list of peering group node attachments. 4589 ''' 4590 deadline = None if timeout is None else time.time() + timeout 4591 req = PeeringGroupNodeListRequest() 4592 req.meta.CopyFrom(ListRequestMetadata()) 4593 if self.parent.page_limit > 0: 4594 req.meta.limit = self.parent.page_limit 4595 if self.parent.snapshot_datetime is not None: 4596 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4597 4598 req.filter = plumbing.quote_filter_args(filter, *args) 4599 4600 def generator(svc, req): 4601 tries = 0 4602 while True: 4603 t = None if deadline is None else deadline - time.time() 4604 try: 4605 plumbing_response = svc.stub.List( 4606 req, 4607 metadata=svc.parent.get_metadata( 4608 'PeeringGroupNodes.List', req), 4609 timeout=t) 4610 except Exception as e: 4611 if self.parent.shouldRetry(tries, e, deadline): 4612 tries += 1 4613 time.sleep( 4614 self.parent.exponentialBackoff(tries, deadline)) 4615 continue 4616 raise plumbing.convert_error_to_porcelain(e) from e 4617 tries = 0 4618 for plumbing_item in plumbing_response.peering_group_nodes: 4619 yield plumbing.convert_peering_group_node_to_porcelain( 4620 plumbing_item) 4621 if plumbing_response.meta.next_cursor == '': 4622 break 4623 req.meta.cursor = plumbing_response.meta.next_cursor 4624 4625 return generator(self, req) 4626 4627 4628class PeeringGroupPeers: 4629 ''' 4630 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4631 See `strongdm.models.PeeringGroupPeer`. 4632 ''' 4633 def __init__(self, channel, client): 4634 self.parent = client 4635 self.stub = PeeringGroupPeersStub(channel) 4636 4637 def create(self, peering_group_peer, timeout=None): 4638 ''' 4639 Create links two peering groups. 4640 ''' 4641 deadline = None if timeout is None else time.time() + timeout 4642 req = PeeringGroupPeerCreateRequest() 4643 4644 if peering_group_peer is not None: 4645 req.peering_group_peer.CopyFrom( 4646 plumbing.convert_peering_group_peer_to_plumbing( 4647 peering_group_peer)) 4648 tries = 0 4649 plumbing_response = None 4650 while True: 4651 t = None if deadline is None else deadline - time.time() 4652 try: 4653 plumbing_response = self.stub.Create( 4654 req, 4655 metadata=self.parent.get_metadata( 4656 'PeeringGroupPeers.Create', req), 4657 timeout=t) 4658 except Exception as e: 4659 if self.parent.shouldRetry(tries, e, deadline): 4660 tries += 1 4661 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4662 continue 4663 raise plumbing.convert_error_to_porcelain(e) from e 4664 break 4665 4666 resp = models.PeeringGroupPeerCreateResponse() 4667 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4668 plumbing_response.meta) 4669 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4670 plumbing_response.peering_group_peer) 4671 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4672 plumbing_response.rate_limit) 4673 return resp 4674 4675 def delete(self, id, timeout=None): 4676 ''' 4677 Delete unlinks two peering groups. 4678 ''' 4679 deadline = None if timeout is None else time.time() + timeout 4680 req = PeeringGroupPeerDeleteRequest() 4681 4682 req.id = (id) 4683 tries = 0 4684 plumbing_response = None 4685 while True: 4686 t = None if deadline is None else deadline - time.time() 4687 try: 4688 plumbing_response = self.stub.Delete( 4689 req, 4690 metadata=self.parent.get_metadata( 4691 'PeeringGroupPeers.Delete', req), 4692 timeout=t) 4693 except Exception as e: 4694 if self.parent.shouldRetry(tries, e, deadline): 4695 tries += 1 4696 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4697 continue 4698 raise plumbing.convert_error_to_porcelain(e) from e 4699 break 4700 4701 resp = models.PeeringGroupPeerDeleteResponse() 4702 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4703 plumbing_response.meta) 4704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4705 plumbing_response.rate_limit) 4706 return resp 4707 4708 def get(self, id, timeout=None): 4709 ''' 4710 Get reads the information of one peering group link. 4711 ''' 4712 deadline = None if timeout is None else time.time() + timeout 4713 req = PeeringGroupPeerGetRequest() 4714 if self.parent.snapshot_datetime is not None: 4715 req.meta.CopyFrom(GetRequestMetadata()) 4716 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4717 4718 req.id = (id) 4719 tries = 0 4720 plumbing_response = None 4721 while True: 4722 t = None if deadline is None else deadline - time.time() 4723 try: 4724 plumbing_response = self.stub.Get( 4725 req, 4726 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4727 req), 4728 timeout=t) 4729 except Exception as e: 4730 if self.parent.shouldRetry(tries, e, deadline): 4731 tries += 1 4732 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4733 continue 4734 raise plumbing.convert_error_to_porcelain(e) from e 4735 break 4736 4737 resp = models.PeeringGroupPeerGetResponse() 4738 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4739 plumbing_response.meta) 4740 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4741 plumbing_response.peering_group_peer) 4742 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4743 plumbing_response.rate_limit) 4744 return resp 4745 4746 def list(self, filter, *args, timeout=None): 4747 ''' 4748 List gets a list of peering group links. 4749 ''' 4750 deadline = None if timeout is None else time.time() + timeout 4751 req = PeeringGroupPeerListRequest() 4752 req.meta.CopyFrom(ListRequestMetadata()) 4753 if self.parent.page_limit > 0: 4754 req.meta.limit = self.parent.page_limit 4755 if self.parent.snapshot_datetime is not None: 4756 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4757 4758 req.filter = plumbing.quote_filter_args(filter, *args) 4759 4760 def generator(svc, req): 4761 tries = 0 4762 while True: 4763 t = None if deadline is None else deadline - time.time() 4764 try: 4765 plumbing_response = svc.stub.List( 4766 req, 4767 metadata=svc.parent.get_metadata( 4768 'PeeringGroupPeers.List', req), 4769 timeout=t) 4770 except Exception as e: 4771 if self.parent.shouldRetry(tries, e, deadline): 4772 tries += 1 4773 time.sleep( 4774 self.parent.exponentialBackoff(tries, deadline)) 4775 continue 4776 raise plumbing.convert_error_to_porcelain(e) from e 4777 tries = 0 4778 for plumbing_item in plumbing_response.peering_group_peers: 4779 yield plumbing.convert_peering_group_peer_to_porcelain( 4780 plumbing_item) 4781 if plumbing_response.meta.next_cursor == '': 4782 break 4783 req.meta.cursor = plumbing_response.meta.next_cursor 4784 4785 return generator(self, req) 4786 4787 4788class PeeringGroupResources: 4789 ''' 4790 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4791 See `strongdm.models.PeeringGroupResource`. 4792 ''' 4793 def __init__(self, channel, client): 4794 self.parent = client 4795 self.stub = PeeringGroupResourcesStub(channel) 4796 4797 def create(self, peering_group_resource, timeout=None): 4798 ''' 4799 Create attaches a Resource to a PeeringGroup 4800 ''' 4801 deadline = None if timeout is None else time.time() + timeout 4802 req = PeeringGroupResourceCreateRequest() 4803 4804 if peering_group_resource is not None: 4805 req.peering_group_resource.CopyFrom( 4806 plumbing.convert_peering_group_resource_to_plumbing( 4807 peering_group_resource)) 4808 tries = 0 4809 plumbing_response = None 4810 while True: 4811 t = None if deadline is None else deadline - time.time() 4812 try: 4813 plumbing_response = self.stub.Create( 4814 req, 4815 metadata=self.parent.get_metadata( 4816 'PeeringGroupResources.Create', req), 4817 timeout=t) 4818 except Exception as e: 4819 if self.parent.shouldRetry(tries, e, deadline): 4820 tries += 1 4821 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4822 continue 4823 raise plumbing.convert_error_to_porcelain(e) from e 4824 break 4825 4826 resp = models.PeeringGroupResourceCreateResponse() 4827 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4828 plumbing_response.meta) 4829 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4830 plumbing_response.peering_group_resource) 4831 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4832 plumbing_response.rate_limit) 4833 return resp 4834 4835 def delete(self, id, timeout=None): 4836 ''' 4837 Delete detaches a Resource to a PeeringGroup 4838 ''' 4839 deadline = None if timeout is None else time.time() + timeout 4840 req = PeeringGroupResourceDeleteRequest() 4841 4842 req.id = (id) 4843 tries = 0 4844 plumbing_response = None 4845 while True: 4846 t = None if deadline is None else deadline - time.time() 4847 try: 4848 plumbing_response = self.stub.Delete( 4849 req, 4850 metadata=self.parent.get_metadata( 4851 'PeeringGroupResources.Delete', req), 4852 timeout=t) 4853 except Exception as e: 4854 if self.parent.shouldRetry(tries, e, deadline): 4855 tries += 1 4856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4857 continue 4858 raise plumbing.convert_error_to_porcelain(e) from e 4859 break 4860 4861 resp = models.PeeringGroupResourceDeleteResponse() 4862 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4863 plumbing_response.meta) 4864 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4865 plumbing_response.rate_limit) 4866 return resp 4867 4868 def get(self, id, timeout=None): 4869 ''' 4870 Get reads the information of one peering group to resource attachment. 4871 ''' 4872 deadline = None if timeout is None else time.time() + timeout 4873 req = PeeringGroupResourceGetRequest() 4874 if self.parent.snapshot_datetime is not None: 4875 req.meta.CopyFrom(GetRequestMetadata()) 4876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4877 4878 req.id = (id) 4879 tries = 0 4880 plumbing_response = None 4881 while True: 4882 t = None if deadline is None else deadline - time.time() 4883 try: 4884 plumbing_response = self.stub.Get( 4885 req, 4886 metadata=self.parent.get_metadata( 4887 'PeeringGroupResources.Get', req), 4888 timeout=t) 4889 except Exception as e: 4890 if self.parent.shouldRetry(tries, e, deadline): 4891 tries += 1 4892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4893 continue 4894 raise plumbing.convert_error_to_porcelain(e) from e 4895 break 4896 4897 resp = models.PeeringGroupResourceGetResponse() 4898 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4899 plumbing_response.meta) 4900 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4901 plumbing_response.peering_group_resource) 4902 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4903 plumbing_response.rate_limit) 4904 return resp 4905 4906 def list(self, filter, *args, timeout=None): 4907 ''' 4908 List gets a list of peering group resource attachments. 4909 ''' 4910 deadline = None if timeout is None else time.time() + timeout 4911 req = PeeringGroupResourceListRequest() 4912 req.meta.CopyFrom(ListRequestMetadata()) 4913 if self.parent.page_limit > 0: 4914 req.meta.limit = self.parent.page_limit 4915 if self.parent.snapshot_datetime is not None: 4916 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4917 4918 req.filter = plumbing.quote_filter_args(filter, *args) 4919 4920 def generator(svc, req): 4921 tries = 0 4922 while True: 4923 t = None if deadline is None else deadline - time.time() 4924 try: 4925 plumbing_response = svc.stub.List( 4926 req, 4927 metadata=svc.parent.get_metadata( 4928 'PeeringGroupResources.List', req), 4929 timeout=t) 4930 except Exception as e: 4931 if self.parent.shouldRetry(tries, e, deadline): 4932 tries += 1 4933 time.sleep( 4934 self.parent.exponentialBackoff(tries, deadline)) 4935 continue 4936 raise plumbing.convert_error_to_porcelain(e) from e 4937 tries = 0 4938 for plumbing_item in plumbing_response.peering_group_resources: 4939 yield plumbing.convert_peering_group_resource_to_porcelain( 4940 plumbing_item) 4941 if plumbing_response.meta.next_cursor == '': 4942 break 4943 req.meta.cursor = plumbing_response.meta.next_cursor 4944 4945 return generator(self, req) 4946 4947 4948class PeeringGroups: 4949 ''' 4950 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4951 See `strongdm.models.PeeringGroup`. 4952 ''' 4953 def __init__(self, channel, client): 4954 self.parent = client 4955 self.stub = PeeringGroupsStub(channel) 4956 4957 def create(self, peering_group, timeout=None): 4958 ''' 4959 Create registers a new PeeringGroup. 4960 ''' 4961 deadline = None if timeout is None else time.time() + timeout 4962 req = PeeringGroupCreateRequest() 4963 4964 if peering_group is not None: 4965 req.peering_group.CopyFrom( 4966 plumbing.convert_peering_group_to_plumbing(peering_group)) 4967 tries = 0 4968 plumbing_response = None 4969 while True: 4970 t = None if deadline is None else deadline - time.time() 4971 try: 4972 plumbing_response = self.stub.Create( 4973 req, 4974 metadata=self.parent.get_metadata('PeeringGroups.Create', 4975 req), 4976 timeout=t) 4977 except Exception as e: 4978 if self.parent.shouldRetry(tries, e, deadline): 4979 tries += 1 4980 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4981 continue 4982 raise plumbing.convert_error_to_porcelain(e) from e 4983 break 4984 4985 resp = models.PeeringGroupCreateResponse() 4986 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4987 plumbing_response.meta) 4988 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4989 plumbing_response.peering_group) 4990 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4991 plumbing_response.rate_limit) 4992 return resp 4993 4994 def delete(self, id, timeout=None): 4995 ''' 4996 Delete removes a PeeringGroup by ID. 4997 ''' 4998 deadline = None if timeout is None else time.time() + timeout 4999 req = PeeringGroupDeleteRequest() 5000 5001 req.id = (id) 5002 tries = 0 5003 plumbing_response = None 5004 while True: 5005 t = None if deadline is None else deadline - time.time() 5006 try: 5007 plumbing_response = self.stub.Delete( 5008 req, 5009 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5010 req), 5011 timeout=t) 5012 except Exception as e: 5013 if self.parent.shouldRetry(tries, e, deadline): 5014 tries += 1 5015 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5016 continue 5017 raise plumbing.convert_error_to_porcelain(e) from e 5018 break 5019 5020 resp = models.PeeringGroupDeleteResponse() 5021 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5022 plumbing_response.meta) 5023 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5024 plumbing_response.rate_limit) 5025 return resp 5026 5027 def get(self, id, timeout=None): 5028 ''' 5029 Get reads one PeeringGroup by ID. It will load all its dependencies. 5030 ''' 5031 deadline = None if timeout is None else time.time() + timeout 5032 req = PeeringGroupGetRequest() 5033 if self.parent.snapshot_datetime is not None: 5034 req.meta.CopyFrom(GetRequestMetadata()) 5035 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5036 5037 req.id = (id) 5038 tries = 0 5039 plumbing_response = None 5040 while True: 5041 t = None if deadline is None else deadline - time.time() 5042 try: 5043 plumbing_response = self.stub.Get( 5044 req, 5045 metadata=self.parent.get_metadata('PeeringGroups.Get', 5046 req), 5047 timeout=t) 5048 except Exception as e: 5049 if self.parent.shouldRetry(tries, e, deadline): 5050 tries += 1 5051 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5052 continue 5053 raise plumbing.convert_error_to_porcelain(e) from e 5054 break 5055 5056 resp = models.PeeringGroupGetResponse() 5057 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5058 plumbing_response.meta) 5059 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5060 plumbing_response.peering_group) 5061 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5062 plumbing_response.rate_limit) 5063 return resp 5064 5065 def list(self, filter, *args, timeout=None): 5066 ''' 5067 List gets a list of Peering Groups. 5068 ''' 5069 deadline = None if timeout is None else time.time() + timeout 5070 req = PeeringGroupListRequest() 5071 req.meta.CopyFrom(ListRequestMetadata()) 5072 if self.parent.page_limit > 0: 5073 req.meta.limit = self.parent.page_limit 5074 if self.parent.snapshot_datetime is not None: 5075 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5076 5077 req.filter = plumbing.quote_filter_args(filter, *args) 5078 5079 def generator(svc, req): 5080 tries = 0 5081 while True: 5082 t = None if deadline is None else deadline - time.time() 5083 try: 5084 plumbing_response = svc.stub.List( 5085 req, 5086 metadata=svc.parent.get_metadata( 5087 'PeeringGroups.List', req), 5088 timeout=t) 5089 except Exception as e: 5090 if self.parent.shouldRetry(tries, e, deadline): 5091 tries += 1 5092 time.sleep( 5093 self.parent.exponentialBackoff(tries, deadline)) 5094 continue 5095 raise plumbing.convert_error_to_porcelain(e) from e 5096 tries = 0 5097 for plumbing_item in plumbing_response.peering_groups: 5098 yield plumbing.convert_peering_group_to_porcelain( 5099 plumbing_item) 5100 if plumbing_response.meta.next_cursor == '': 5101 break 5102 req.meta.cursor = plumbing_response.meta.next_cursor 5103 5104 return generator(self, req) 5105 5106 5107class Policies: 5108 ''' 5109 Policies are the collection of one or more statements that enforce fine-grained access 5110 control for the users of an organization. 5111 See `strongdm.models.Policy`. 5112 ''' 5113 def __init__(self, channel, client): 5114 self.parent = client 5115 self.stub = PoliciesStub(channel) 5116 5117 def create(self, policy, timeout=None): 5118 ''' 5119 Create creates a new Policy. 5120 ''' 5121 deadline = None if timeout is None else time.time() + timeout 5122 req = PolicyCreateRequest() 5123 5124 if policy is not None: 5125 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5126 tries = 0 5127 plumbing_response = None 5128 while True: 5129 t = None if deadline is None else deadline - time.time() 5130 try: 5131 plumbing_response = self.stub.Create( 5132 req, 5133 metadata=self.parent.get_metadata('Policies.Create', req), 5134 timeout=t) 5135 except Exception as e: 5136 if self.parent.shouldRetry(tries, e, deadline): 5137 tries += 1 5138 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5139 continue 5140 raise plumbing.convert_error_to_porcelain(e) from e 5141 break 5142 5143 resp = models.PolicyCreateResponse() 5144 resp.policy = plumbing.convert_policy_to_porcelain( 5145 plumbing_response.policy) 5146 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5147 plumbing_response.rate_limit) 5148 return resp 5149 5150 def delete(self, id, timeout=None): 5151 ''' 5152 Delete removes a Policy by ID. 5153 ''' 5154 deadline = None if timeout is None else time.time() + timeout 5155 req = PolicyDeleteRequest() 5156 5157 req.id = (id) 5158 tries = 0 5159 plumbing_response = None 5160 while True: 5161 t = None if deadline is None else deadline - time.time() 5162 try: 5163 plumbing_response = self.stub.Delete( 5164 req, 5165 metadata=self.parent.get_metadata('Policies.Delete', req), 5166 timeout=t) 5167 except Exception as e: 5168 if self.parent.shouldRetry(tries, e, deadline): 5169 tries += 1 5170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5171 continue 5172 raise plumbing.convert_error_to_porcelain(e) from e 5173 break 5174 5175 resp = models.PolicyDeleteResponse() 5176 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5177 plumbing_response.rate_limit) 5178 return resp 5179 5180 def update(self, policy, timeout=None): 5181 ''' 5182 Update replaces all the fields of a Policy by ID. 5183 ''' 5184 deadline = None if timeout is None else time.time() + timeout 5185 req = PolicyUpdateRequest() 5186 5187 if policy is not None: 5188 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5189 tries = 0 5190 plumbing_response = None 5191 while True: 5192 t = None if deadline is None else deadline - time.time() 5193 try: 5194 plumbing_response = self.stub.Update( 5195 req, 5196 metadata=self.parent.get_metadata('Policies.Update', req), 5197 timeout=t) 5198 except Exception as e: 5199 if self.parent.shouldRetry(tries, e, deadline): 5200 tries += 1 5201 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5202 continue 5203 raise plumbing.convert_error_to_porcelain(e) from e 5204 break 5205 5206 resp = models.PolicyUpdateResponse() 5207 resp.policy = plumbing.convert_policy_to_porcelain( 5208 plumbing_response.policy) 5209 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5210 plumbing_response.rate_limit) 5211 return resp 5212 5213 def get(self, id, timeout=None): 5214 ''' 5215 Get reads one Policy by ID. 5216 ''' 5217 deadline = None if timeout is None else time.time() + timeout 5218 req = PolicyGetRequest() 5219 if self.parent.snapshot_datetime is not None: 5220 req.meta.CopyFrom(GetRequestMetadata()) 5221 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5222 5223 req.id = (id) 5224 tries = 0 5225 plumbing_response = None 5226 while True: 5227 t = None if deadline is None else deadline - time.time() 5228 try: 5229 plumbing_response = self.stub.Get( 5230 req, 5231 metadata=self.parent.get_metadata('Policies.Get', req), 5232 timeout=t) 5233 except Exception as e: 5234 if self.parent.shouldRetry(tries, e, deadline): 5235 tries += 1 5236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5237 continue 5238 raise plumbing.convert_error_to_porcelain(e) from e 5239 break 5240 5241 resp = models.PolicyGetResponse() 5242 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5243 plumbing_response.meta) 5244 resp.policy = plumbing.convert_policy_to_porcelain( 5245 plumbing_response.policy) 5246 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5247 plumbing_response.rate_limit) 5248 return resp 5249 5250 def list(self, filter, *args, timeout=None): 5251 ''' 5252 List gets a list of Policy matching a given set of criteria 5253 ''' 5254 deadline = None if timeout is None else time.time() + timeout 5255 req = PolicyListRequest() 5256 req.meta.CopyFrom(ListRequestMetadata()) 5257 if self.parent.page_limit > 0: 5258 req.meta.limit = self.parent.page_limit 5259 if self.parent.snapshot_datetime is not None: 5260 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5261 5262 req.filter = plumbing.quote_filter_args(filter, *args) 5263 5264 def generator(svc, req): 5265 tries = 0 5266 while True: 5267 t = None if deadline is None else deadline - time.time() 5268 try: 5269 plumbing_response = svc.stub.List( 5270 req, 5271 metadata=svc.parent.get_metadata('Policies.List', req), 5272 timeout=t) 5273 except Exception as e: 5274 if self.parent.shouldRetry(tries, e, deadline): 5275 tries += 1 5276 time.sleep( 5277 self.parent.exponentialBackoff(tries, deadline)) 5278 continue 5279 raise plumbing.convert_error_to_porcelain(e) from e 5280 tries = 0 5281 for plumbing_item in plumbing_response.policies: 5282 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5283 if plumbing_response.meta.next_cursor == '': 5284 break 5285 req.meta.cursor = plumbing_response.meta.next_cursor 5286 5287 return generator(self, req) 5288 5289 5290class SnapshotPolicies: 5291 ''' 5292 SnapshotPolicies exposes the read only methods of the Policies 5293 service for historical queries. 5294 ''' 5295 def __init__(self, policies): 5296 self.policies = policies 5297 5298 def get(self, id, timeout=None): 5299 ''' 5300 Get reads one Policy by ID. 5301 ''' 5302 return self.policies.get(id, timeout=timeout) 5303 5304 def list(self, filter, *args, timeout=None): 5305 ''' 5306 List gets a list of Policy matching a given set of criteria 5307 ''' 5308 return self.policies.list(filter, *args, timeout=timeout) 5309 5310 5311class PoliciesHistory: 5312 ''' 5313 PoliciesHistory records all changes to the state of a Policy. 5314 See `strongdm.models.PolicyHistory`. 5315 ''' 5316 def __init__(self, channel, client): 5317 self.parent = client 5318 self.stub = PoliciesHistoryStub(channel) 5319 5320 def list(self, filter, *args, timeout=None): 5321 ''' 5322 List gets a list of PolicyHistory records matching a given set of criteria. 5323 ''' 5324 deadline = None if timeout is None else time.time() + timeout 5325 req = PoliciesHistoryListRequest() 5326 req.meta.CopyFrom(ListRequestMetadata()) 5327 if self.parent.page_limit > 0: 5328 req.meta.limit = self.parent.page_limit 5329 if self.parent.snapshot_datetime is not None: 5330 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5331 5332 req.filter = plumbing.quote_filter_args(filter, *args) 5333 5334 def generator(svc, req): 5335 tries = 0 5336 while True: 5337 t = None if deadline is None else deadline - time.time() 5338 try: 5339 plumbing_response = svc.stub.List( 5340 req, 5341 metadata=svc.parent.get_metadata( 5342 'PoliciesHistory.List', req), 5343 timeout=t) 5344 except Exception as e: 5345 if self.parent.shouldRetry(tries, e, deadline): 5346 tries += 1 5347 time.sleep( 5348 self.parent.exponentialBackoff(tries, deadline)) 5349 continue 5350 raise plumbing.convert_error_to_porcelain(e) from e 5351 tries = 0 5352 for plumbing_item in plumbing_response.history: 5353 yield plumbing.convert_policy_history_to_porcelain( 5354 plumbing_item) 5355 if plumbing_response.meta.next_cursor == '': 5356 break 5357 req.meta.cursor = plumbing_response.meta.next_cursor 5358 5359 return generator(self, req) 5360 5361 5362class ProxyClusterKeys: 5363 ''' 5364 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5365 The proxies within a cluster share the same key. One cluster can have 5366 multiple keys in order to facilitate key rotation. 5367 See `strongdm.models.ProxyClusterKey`. 5368 ''' 5369 def __init__(self, channel, client): 5370 self.parent = client 5371 self.stub = ProxyClusterKeysStub(channel) 5372 5373 def create(self, proxy_cluster_key, timeout=None): 5374 ''' 5375 Create registers a new ProxyClusterKey. 5376 ''' 5377 deadline = None if timeout is None else time.time() + timeout 5378 req = ProxyClusterKeyCreateRequest() 5379 5380 if proxy_cluster_key is not None: 5381 req.proxy_cluster_key.CopyFrom( 5382 plumbing.convert_proxy_cluster_key_to_plumbing( 5383 proxy_cluster_key)) 5384 tries = 0 5385 plumbing_response = None 5386 while True: 5387 t = None if deadline is None else deadline - time.time() 5388 try: 5389 plumbing_response = self.stub.Create( 5390 req, 5391 metadata=self.parent.get_metadata( 5392 'ProxyClusterKeys.Create', req), 5393 timeout=t) 5394 except Exception as e: 5395 if self.parent.shouldRetry(tries, e, deadline): 5396 tries += 1 5397 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5398 continue 5399 raise plumbing.convert_error_to_porcelain(e) from e 5400 break 5401 5402 resp = models.ProxyClusterKeyCreateResponse() 5403 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5404 plumbing_response.meta) 5405 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5406 plumbing_response.proxy_cluster_key) 5407 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5408 plumbing_response.rate_limit) 5409 resp.secret_key = (plumbing_response.secret_key) 5410 return resp 5411 5412 def get(self, id, timeout=None): 5413 ''' 5414 Get reads one ProxyClusterKey by ID. 5415 ''' 5416 deadline = None if timeout is None else time.time() + timeout 5417 req = ProxyClusterKeyGetRequest() 5418 if self.parent.snapshot_datetime is not None: 5419 req.meta.CopyFrom(GetRequestMetadata()) 5420 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5421 5422 req.id = (id) 5423 tries = 0 5424 plumbing_response = None 5425 while True: 5426 t = None if deadline is None else deadline - time.time() 5427 try: 5428 plumbing_response = self.stub.Get( 5429 req, 5430 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5431 req), 5432 timeout=t) 5433 except Exception as e: 5434 if self.parent.shouldRetry(tries, e, deadline): 5435 tries += 1 5436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5437 continue 5438 raise plumbing.convert_error_to_porcelain(e) from e 5439 break 5440 5441 resp = models.ProxyClusterKeyGetResponse() 5442 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5443 plumbing_response.meta) 5444 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5445 plumbing_response.proxy_cluster_key) 5446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5447 plumbing_response.rate_limit) 5448 return resp 5449 5450 def delete(self, id, timeout=None): 5451 ''' 5452 Delete removes a ProxyClusterKey by ID. 5453 ''' 5454 deadline = None if timeout is None else time.time() + timeout 5455 req = ProxyClusterKeyDeleteRequest() 5456 5457 req.id = (id) 5458 tries = 0 5459 plumbing_response = None 5460 while True: 5461 t = None if deadline is None else deadline - time.time() 5462 try: 5463 plumbing_response = self.stub.Delete( 5464 req, 5465 metadata=self.parent.get_metadata( 5466 'ProxyClusterKeys.Delete', req), 5467 timeout=t) 5468 except Exception as e: 5469 if self.parent.shouldRetry(tries, e, deadline): 5470 tries += 1 5471 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5472 continue 5473 raise plumbing.convert_error_to_porcelain(e) from e 5474 break 5475 5476 resp = models.ProxyClusterKeyDeleteResponse() 5477 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5478 plumbing_response.meta) 5479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5480 plumbing_response.rate_limit) 5481 return resp 5482 5483 def list(self, filter, *args, timeout=None): 5484 ''' 5485 List gets a list of ProxyClusterKeys matching a given set of criteria. 5486 ''' 5487 deadline = None if timeout is None else time.time() + timeout 5488 req = ProxyClusterKeyListRequest() 5489 req.meta.CopyFrom(ListRequestMetadata()) 5490 if self.parent.page_limit > 0: 5491 req.meta.limit = self.parent.page_limit 5492 if self.parent.snapshot_datetime is not None: 5493 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5494 5495 req.filter = plumbing.quote_filter_args(filter, *args) 5496 5497 def generator(svc, req): 5498 tries = 0 5499 while True: 5500 t = None if deadline is None else deadline - time.time() 5501 try: 5502 plumbing_response = svc.stub.List( 5503 req, 5504 metadata=svc.parent.get_metadata( 5505 'ProxyClusterKeys.List', req), 5506 timeout=t) 5507 except Exception as e: 5508 if self.parent.shouldRetry(tries, e, deadline): 5509 tries += 1 5510 time.sleep( 5511 self.parent.exponentialBackoff(tries, deadline)) 5512 continue 5513 raise plumbing.convert_error_to_porcelain(e) from e 5514 tries = 0 5515 for plumbing_item in plumbing_response.proxy_cluster_keys: 5516 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5517 plumbing_item) 5518 if plumbing_response.meta.next_cursor == '': 5519 break 5520 req.meta.cursor = plumbing_response.meta.next_cursor 5521 5522 return generator(self, req) 5523 5524 5525class SnapshotProxyClusterKeys: 5526 ''' 5527 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5528 service for historical queries. 5529 ''' 5530 def __init__(self, proxy_cluster_keys): 5531 self.proxy_cluster_keys = proxy_cluster_keys 5532 5533 def get(self, id, timeout=None): 5534 ''' 5535 Get reads one ProxyClusterKey by ID. 5536 ''' 5537 return self.proxy_cluster_keys.get(id, timeout=timeout) 5538 5539 def list(self, filter, *args, timeout=None): 5540 ''' 5541 List gets a list of ProxyClusterKeys matching a given set of criteria. 5542 ''' 5543 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 5544 5545 5546class Queries: 5547 ''' 5548 A Query is a record of a single client request to a resource, such as a SQL query. 5549 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5550 The Queries service is read-only. 5551 See `strongdm.models.Query`. 5552 ''' 5553 def __init__(self, channel, client): 5554 self.parent = client 5555 self.stub = QueriesStub(channel) 5556 5557 def list(self, filter, *args, timeout=None): 5558 ''' 5559 List gets a list of Queries matching a given set of criteria. 5560 ''' 5561 deadline = None if timeout is None else time.time() + timeout 5562 req = QueryListRequest() 5563 req.meta.CopyFrom(ListRequestMetadata()) 5564 if self.parent.page_limit > 0: 5565 req.meta.limit = self.parent.page_limit 5566 if self.parent.snapshot_datetime is not None: 5567 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5568 5569 req.filter = plumbing.quote_filter_args(filter, *args) 5570 5571 def generator(svc, req): 5572 tries = 0 5573 while True: 5574 t = None if deadline is None else deadline - time.time() 5575 try: 5576 plumbing_response = svc.stub.List( 5577 req, 5578 metadata=svc.parent.get_metadata('Queries.List', req), 5579 timeout=t) 5580 except Exception as e: 5581 if self.parent.shouldRetry(tries, e, deadline): 5582 tries += 1 5583 time.sleep( 5584 self.parent.exponentialBackoff(tries, deadline)) 5585 continue 5586 raise plumbing.convert_error_to_porcelain(e) from e 5587 tries = 0 5588 for plumbing_item in plumbing_response.queries: 5589 yield plumbing.convert_query_to_porcelain(plumbing_item) 5590 if plumbing_response.meta.next_cursor == '': 5591 break 5592 req.meta.cursor = plumbing_response.meta.next_cursor 5593 5594 return generator(self, req) 5595 5596 5597class RemoteIdentities: 5598 ''' 5599 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5600 See `strongdm.models.RemoteIdentity`. 5601 ''' 5602 def __init__(self, channel, client): 5603 self.parent = client 5604 self.stub = RemoteIdentitiesStub(channel) 5605 5606 def create(self, remote_identity, timeout=None): 5607 ''' 5608 Create registers a new RemoteIdentity. 5609 ''' 5610 deadline = None if timeout is None else time.time() + timeout 5611 req = RemoteIdentityCreateRequest() 5612 5613 if remote_identity is not None: 5614 req.remote_identity.CopyFrom( 5615 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5616 tries = 0 5617 plumbing_response = None 5618 while True: 5619 t = None if deadline is None else deadline - time.time() 5620 try: 5621 plumbing_response = self.stub.Create( 5622 req, 5623 metadata=self.parent.get_metadata( 5624 'RemoteIdentities.Create', req), 5625 timeout=t) 5626 except Exception as e: 5627 if self.parent.shouldRetry(tries, e, deadline): 5628 tries += 1 5629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5630 continue 5631 raise plumbing.convert_error_to_porcelain(e) from e 5632 break 5633 5634 resp = models.RemoteIdentityCreateResponse() 5635 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5636 plumbing_response.meta) 5637 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5638 plumbing_response.rate_limit) 5639 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5640 plumbing_response.remote_identity) 5641 return resp 5642 5643 def get(self, id, timeout=None): 5644 ''' 5645 Get reads one RemoteIdentity by ID. 5646 ''' 5647 deadline = None if timeout is None else time.time() + timeout 5648 req = RemoteIdentityGetRequest() 5649 if self.parent.snapshot_datetime is not None: 5650 req.meta.CopyFrom(GetRequestMetadata()) 5651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5652 5653 req.id = (id) 5654 tries = 0 5655 plumbing_response = None 5656 while True: 5657 t = None if deadline is None else deadline - time.time() 5658 try: 5659 plumbing_response = self.stub.Get( 5660 req, 5661 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5662 req), 5663 timeout=t) 5664 except Exception as e: 5665 if self.parent.shouldRetry(tries, e, deadline): 5666 tries += 1 5667 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5668 continue 5669 raise plumbing.convert_error_to_porcelain(e) from e 5670 break 5671 5672 resp = models.RemoteIdentityGetResponse() 5673 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5674 plumbing_response.meta) 5675 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5676 plumbing_response.rate_limit) 5677 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5678 plumbing_response.remote_identity) 5679 return resp 5680 5681 def update(self, remote_identity, timeout=None): 5682 ''' 5683 Update replaces all the fields of a RemoteIdentity by ID. 5684 ''' 5685 deadline = None if timeout is None else time.time() + timeout 5686 req = RemoteIdentityUpdateRequest() 5687 5688 if remote_identity is not None: 5689 req.remote_identity.CopyFrom( 5690 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5691 tries = 0 5692 plumbing_response = None 5693 while True: 5694 t = None if deadline is None else deadline - time.time() 5695 try: 5696 plumbing_response = self.stub.Update( 5697 req, 5698 metadata=self.parent.get_metadata( 5699 'RemoteIdentities.Update', req), 5700 timeout=t) 5701 except Exception as e: 5702 if self.parent.shouldRetry(tries, e, deadline): 5703 tries += 1 5704 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5705 continue 5706 raise plumbing.convert_error_to_porcelain(e) from e 5707 break 5708 5709 resp = models.RemoteIdentityUpdateResponse() 5710 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5711 plumbing_response.meta) 5712 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5713 plumbing_response.rate_limit) 5714 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5715 plumbing_response.remote_identity) 5716 return resp 5717 5718 def delete(self, id, timeout=None): 5719 ''' 5720 Delete removes a RemoteIdentity by ID. 5721 ''' 5722 deadline = None if timeout is None else time.time() + timeout 5723 req = RemoteIdentityDeleteRequest() 5724 5725 req.id = (id) 5726 tries = 0 5727 plumbing_response = None 5728 while True: 5729 t = None if deadline is None else deadline - time.time() 5730 try: 5731 plumbing_response = self.stub.Delete( 5732 req, 5733 metadata=self.parent.get_metadata( 5734 'RemoteIdentities.Delete', req), 5735 timeout=t) 5736 except Exception as e: 5737 if self.parent.shouldRetry(tries, e, deadline): 5738 tries += 1 5739 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5740 continue 5741 raise plumbing.convert_error_to_porcelain(e) from e 5742 break 5743 5744 resp = models.RemoteIdentityDeleteResponse() 5745 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5746 plumbing_response.meta) 5747 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5748 plumbing_response.rate_limit) 5749 return resp 5750 5751 def list(self, filter, *args, timeout=None): 5752 ''' 5753 List gets a list of RemoteIdentities matching a given set of criteria. 5754 ''' 5755 deadline = None if timeout is None else time.time() + timeout 5756 req = RemoteIdentityListRequest() 5757 req.meta.CopyFrom(ListRequestMetadata()) 5758 if self.parent.page_limit > 0: 5759 req.meta.limit = self.parent.page_limit 5760 if self.parent.snapshot_datetime is not None: 5761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5762 5763 req.filter = plumbing.quote_filter_args(filter, *args) 5764 5765 def generator(svc, req): 5766 tries = 0 5767 while True: 5768 t = None if deadline is None else deadline - time.time() 5769 try: 5770 plumbing_response = svc.stub.List( 5771 req, 5772 metadata=svc.parent.get_metadata( 5773 'RemoteIdentities.List', req), 5774 timeout=t) 5775 except Exception as e: 5776 if self.parent.shouldRetry(tries, e, deadline): 5777 tries += 1 5778 time.sleep( 5779 self.parent.exponentialBackoff(tries, deadline)) 5780 continue 5781 raise plumbing.convert_error_to_porcelain(e) from e 5782 tries = 0 5783 for plumbing_item in plumbing_response.remote_identities: 5784 yield plumbing.convert_remote_identity_to_porcelain( 5785 plumbing_item) 5786 if plumbing_response.meta.next_cursor == '': 5787 break 5788 req.meta.cursor = plumbing_response.meta.next_cursor 5789 5790 return generator(self, req) 5791 5792 5793class SnapshotRemoteIdentities: 5794 ''' 5795 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5796 service for historical queries. 5797 ''' 5798 def __init__(self, remote_identities): 5799 self.remote_identities = remote_identities 5800 5801 def get(self, id, timeout=None): 5802 ''' 5803 Get reads one RemoteIdentity by ID. 5804 ''' 5805 return self.remote_identities.get(id, timeout=timeout) 5806 5807 def list(self, filter, *args, timeout=None): 5808 ''' 5809 List gets a list of RemoteIdentities matching a given set of criteria. 5810 ''' 5811 return self.remote_identities.list(filter, *args, timeout=timeout) 5812 5813 5814class RemoteIdentitiesHistory: 5815 ''' 5816 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5817 See `strongdm.models.RemoteIdentityHistory`. 5818 ''' 5819 def __init__(self, channel, client): 5820 self.parent = client 5821 self.stub = RemoteIdentitiesHistoryStub(channel) 5822 5823 def list(self, filter, *args, timeout=None): 5824 ''' 5825 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5826 ''' 5827 deadline = None if timeout is None else time.time() + timeout 5828 req = RemoteIdentityHistoryListRequest() 5829 req.meta.CopyFrom(ListRequestMetadata()) 5830 if self.parent.page_limit > 0: 5831 req.meta.limit = self.parent.page_limit 5832 if self.parent.snapshot_datetime is not None: 5833 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5834 5835 req.filter = plumbing.quote_filter_args(filter, *args) 5836 5837 def generator(svc, req): 5838 tries = 0 5839 while True: 5840 t = None if deadline is None else deadline - time.time() 5841 try: 5842 plumbing_response = svc.stub.List( 5843 req, 5844 metadata=svc.parent.get_metadata( 5845 'RemoteIdentitiesHistory.List', req), 5846 timeout=t) 5847 except Exception as e: 5848 if self.parent.shouldRetry(tries, e, deadline): 5849 tries += 1 5850 time.sleep( 5851 self.parent.exponentialBackoff(tries, deadline)) 5852 continue 5853 raise plumbing.convert_error_to_porcelain(e) from e 5854 tries = 0 5855 for plumbing_item in plumbing_response.history: 5856 yield plumbing.convert_remote_identity_history_to_porcelain( 5857 plumbing_item) 5858 if plumbing_response.meta.next_cursor == '': 5859 break 5860 req.meta.cursor = plumbing_response.meta.next_cursor 5861 5862 return generator(self, req) 5863 5864 5865class RemoteIdentityGroups: 5866 ''' 5867 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5868 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5869 See `strongdm.models.RemoteIdentityGroup`. 5870 ''' 5871 def __init__(self, channel, client): 5872 self.parent = client 5873 self.stub = RemoteIdentityGroupsStub(channel) 5874 5875 def get(self, id, timeout=None): 5876 ''' 5877 Get reads one RemoteIdentityGroup by ID. 5878 ''' 5879 deadline = None if timeout is None else time.time() + timeout 5880 req = RemoteIdentityGroupGetRequest() 5881 if self.parent.snapshot_datetime is not None: 5882 req.meta.CopyFrom(GetRequestMetadata()) 5883 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5884 5885 req.id = (id) 5886 tries = 0 5887 plumbing_response = None 5888 while True: 5889 t = None if deadline is None else deadline - time.time() 5890 try: 5891 plumbing_response = self.stub.Get( 5892 req, 5893 metadata=self.parent.get_metadata( 5894 'RemoteIdentityGroups.Get', req), 5895 timeout=t) 5896 except Exception as e: 5897 if self.parent.shouldRetry(tries, e, deadline): 5898 tries += 1 5899 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5900 continue 5901 raise plumbing.convert_error_to_porcelain(e) from e 5902 break 5903 5904 resp = models.RemoteIdentityGroupGetResponse() 5905 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5906 plumbing_response.meta) 5907 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5908 plumbing_response.rate_limit) 5909 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5910 plumbing_response.remote_identity_group) 5911 return resp 5912 5913 def list(self, filter, *args, timeout=None): 5914 ''' 5915 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5916 ''' 5917 deadline = None if timeout is None else time.time() + timeout 5918 req = RemoteIdentityGroupListRequest() 5919 req.meta.CopyFrom(ListRequestMetadata()) 5920 if self.parent.page_limit > 0: 5921 req.meta.limit = self.parent.page_limit 5922 if self.parent.snapshot_datetime is not None: 5923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5924 5925 req.filter = plumbing.quote_filter_args(filter, *args) 5926 5927 def generator(svc, req): 5928 tries = 0 5929 while True: 5930 t = None if deadline is None else deadline - time.time() 5931 try: 5932 plumbing_response = svc.stub.List( 5933 req, 5934 metadata=svc.parent.get_metadata( 5935 'RemoteIdentityGroups.List', req), 5936 timeout=t) 5937 except Exception as e: 5938 if self.parent.shouldRetry(tries, e, deadline): 5939 tries += 1 5940 time.sleep( 5941 self.parent.exponentialBackoff(tries, deadline)) 5942 continue 5943 raise plumbing.convert_error_to_porcelain(e) from e 5944 tries = 0 5945 for plumbing_item in plumbing_response.remote_identity_groups: 5946 yield plumbing.convert_remote_identity_group_to_porcelain( 5947 plumbing_item) 5948 if plumbing_response.meta.next_cursor == '': 5949 break 5950 req.meta.cursor = plumbing_response.meta.next_cursor 5951 5952 return generator(self, req) 5953 5954 5955class SnapshotRemoteIdentityGroups: 5956 ''' 5957 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5958 service for historical queries. 5959 ''' 5960 def __init__(self, remote_identity_groups): 5961 self.remote_identity_groups = remote_identity_groups 5962 5963 def get(self, id, timeout=None): 5964 ''' 5965 Get reads one RemoteIdentityGroup by ID. 5966 ''' 5967 return self.remote_identity_groups.get(id, timeout=timeout) 5968 5969 def list(self, filter, *args, timeout=None): 5970 ''' 5971 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5972 ''' 5973 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 5974 5975 5976class RemoteIdentityGroupsHistory: 5977 ''' 5978 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 5979 See `strongdm.models.RemoteIdentityGroupHistory`. 5980 ''' 5981 def __init__(self, channel, client): 5982 self.parent = client 5983 self.stub = RemoteIdentityGroupsHistoryStub(channel) 5984 5985 def list(self, filter, *args, timeout=None): 5986 ''' 5987 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5988 ''' 5989 deadline = None if timeout is None else time.time() + timeout 5990 req = RemoteIdentityGroupHistoryListRequest() 5991 req.meta.CopyFrom(ListRequestMetadata()) 5992 if self.parent.page_limit > 0: 5993 req.meta.limit = self.parent.page_limit 5994 if self.parent.snapshot_datetime is not None: 5995 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5996 5997 req.filter = plumbing.quote_filter_args(filter, *args) 5998 5999 def generator(svc, req): 6000 tries = 0 6001 while True: 6002 t = None if deadline is None else deadline - time.time() 6003 try: 6004 plumbing_response = svc.stub.List( 6005 req, 6006 metadata=svc.parent.get_metadata( 6007 'RemoteIdentityGroupsHistory.List', req), 6008 timeout=t) 6009 except Exception as e: 6010 if self.parent.shouldRetry(tries, e, deadline): 6011 tries += 1 6012 time.sleep( 6013 self.parent.exponentialBackoff(tries, deadline)) 6014 continue 6015 raise plumbing.convert_error_to_porcelain(e) from e 6016 tries = 0 6017 for plumbing_item in plumbing_response.history: 6018 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6019 plumbing_item) 6020 if plumbing_response.meta.next_cursor == '': 6021 break 6022 req.meta.cursor = plumbing_response.meta.next_cursor 6023 6024 return generator(self, req) 6025 6026 6027class Replays: 6028 ''' 6029 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6030 (otherwise referred to as a query). The Replays service is read-only. 6031 See `strongdm.models.ReplayChunk`. 6032 ''' 6033 def __init__(self, channel, client): 6034 self.parent = client 6035 self.stub = ReplaysStub(channel) 6036 6037 def list(self, filter, *args, timeout=None): 6038 ''' 6039 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6040 ''' 6041 deadline = None if timeout is None else time.time() + timeout 6042 req = ReplayListRequest() 6043 req.meta.CopyFrom(ListRequestMetadata()) 6044 if self.parent.page_limit > 0: 6045 req.meta.limit = self.parent.page_limit 6046 if self.parent.snapshot_datetime is not None: 6047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6048 6049 req.filter = plumbing.quote_filter_args(filter, *args) 6050 6051 def generator(svc, req): 6052 tries = 0 6053 while True: 6054 t = None if deadline is None else deadline - time.time() 6055 try: 6056 plumbing_response = svc.stub.List( 6057 req, 6058 metadata=svc.parent.get_metadata('Replays.List', req), 6059 timeout=t) 6060 except Exception as e: 6061 if self.parent.shouldRetry(tries, e, deadline): 6062 tries += 1 6063 time.sleep( 6064 self.parent.exponentialBackoff(tries, deadline)) 6065 continue 6066 raise plumbing.convert_error_to_porcelain(e) from e 6067 tries = 0 6068 for plumbing_item in plumbing_response.chunks: 6069 yield plumbing.convert_replay_chunk_to_porcelain( 6070 plumbing_item) 6071 if plumbing_response.meta.next_cursor == '': 6072 break 6073 req.meta.cursor = plumbing_response.meta.next_cursor 6074 6075 return generator(self, req) 6076 6077 6078class Resources: 6079 ''' 6080 Resources are databases, servers, clusters, websites, or clouds that strongDM 6081 delegates access to. 6082 See: 6083 `strongdm.models.Aerospike` 6084 `strongdm.models.AKS` 6085 `strongdm.models.AKSBasicAuth` 6086 `strongdm.models.AKSServiceAccount` 6087 `strongdm.models.AKSServiceAccountUserImpersonation` 6088 `strongdm.models.AKSUserImpersonation` 6089 `strongdm.models.AmazonEKS` 6090 `strongdm.models.AmazonEKSInstanceProfile` 6091 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6092 `strongdm.models.AmazonEKSUserImpersonation` 6093 `strongdm.models.AmazonES` 6094 `strongdm.models.AmazonESIAM` 6095 `strongdm.models.AmazonMQAMQP091` 6096 `strongdm.models.AMQP` 6097 `strongdm.models.Athena` 6098 `strongdm.models.AthenaIAM` 6099 `strongdm.models.AuroraMysql` 6100 `strongdm.models.AuroraMysqlIAM` 6101 `strongdm.models.AuroraPostgres` 6102 `strongdm.models.AuroraPostgresIAM` 6103 `strongdm.models.AWS` 6104 `strongdm.models.AWSConsole` 6105 `strongdm.models.AWSConsoleStaticKeyPair` 6106 `strongdm.models.AWSInstanceProfile` 6107 `strongdm.models.Azure` 6108 `strongdm.models.AzureCertificate` 6109 `strongdm.models.AzureMysql` 6110 `strongdm.models.AzureMysqlManagedIdentity` 6111 `strongdm.models.AzurePostgres` 6112 `strongdm.models.AzurePostgresManagedIdentity` 6113 `strongdm.models.BigQuery` 6114 `strongdm.models.Cassandra` 6115 `strongdm.models.Citus` 6116 `strongdm.models.ClickHouseHTTP` 6117 `strongdm.models.ClickHouseMySQL` 6118 `strongdm.models.ClickHouseTCP` 6119 `strongdm.models.Clustrix` 6120 `strongdm.models.Cockroach` 6121 `strongdm.models.CouchbaseDatabase` 6122 `strongdm.models.CouchbaseWebUI` 6123 `strongdm.models.DB2I` 6124 `strongdm.models.DB2LUW` 6125 `strongdm.models.DocumentDBHost` 6126 `strongdm.models.DocumentDBHostIAM` 6127 `strongdm.models.DocumentDBReplicaSet` 6128 `strongdm.models.DocumentDBReplicaSetIAM` 6129 `strongdm.models.Druid` 6130 `strongdm.models.DynamoDB` 6131 `strongdm.models.DynamoDBIAM` 6132 `strongdm.models.Elastic` 6133 `strongdm.models.ElasticacheRedis` 6134 `strongdm.models.EntraID` 6135 `strongdm.models.GCP` 6136 `strongdm.models.GCPConsole` 6137 `strongdm.models.GCPWIF` 6138 `strongdm.models.GoogleGKE` 6139 `strongdm.models.GoogleGKEUserImpersonation` 6140 `strongdm.models.Greenplum` 6141 `strongdm.models.HTTPAuth` 6142 `strongdm.models.HTTPBasicAuth` 6143 `strongdm.models.HTTPNoAuth` 6144 `strongdm.models.Kubernetes` 6145 `strongdm.models.KubernetesBasicAuth` 6146 `strongdm.models.KubernetesPodIdentity` 6147 `strongdm.models.KubernetesServiceAccount` 6148 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6149 `strongdm.models.KubernetesUserImpersonation` 6150 `strongdm.models.Maria` 6151 `strongdm.models.MCP` 6152 `strongdm.models.Memcached` 6153 `strongdm.models.Memsql` 6154 `strongdm.models.MongoHost` 6155 `strongdm.models.MongoLegacyHost` 6156 `strongdm.models.MongoLegacyReplicaset` 6157 `strongdm.models.MongoReplicaSet` 6158 `strongdm.models.MongoShardedCluster` 6159 `strongdm.models.MTLSMysql` 6160 `strongdm.models.MTLSPostgres` 6161 `strongdm.models.Mysql` 6162 `strongdm.models.Neptune` 6163 `strongdm.models.NeptuneIAM` 6164 `strongdm.models.Oracle` 6165 `strongdm.models.OracleNNE` 6166 `strongdm.models.Postgres` 6167 `strongdm.models.Presto` 6168 `strongdm.models.RabbitMQAMQP091` 6169 `strongdm.models.RawTCP` 6170 `strongdm.models.RDP` 6171 `strongdm.models.RDPCert` 6172 `strongdm.models.RDSPostgresIAM` 6173 `strongdm.models.Redis` 6174 `strongdm.models.RedisCluster` 6175 `strongdm.models.Redshift` 6176 `strongdm.models.RedshiftIAM` 6177 `strongdm.models.RedshiftServerlessIAM` 6178 `strongdm.models.SingleStore` 6179 `strongdm.models.Snowflake` 6180 `strongdm.models.Snowsight` 6181 `strongdm.models.SQLServer` 6182 `strongdm.models.SQLServerAzureAD` 6183 `strongdm.models.SQLServerKerberosAD` 6184 `strongdm.models.SSH` 6185 `strongdm.models.SSHCert` 6186 `strongdm.models.SSHCustomerKey` 6187 `strongdm.models.SSHPassword` 6188 `strongdm.models.Sybase` 6189 `strongdm.models.SybaseIQ` 6190 `strongdm.models.Teradata` 6191 `strongdm.models.Trino` 6192 `strongdm.models.Vertica` 6193 ''' 6194 def __init__(self, channel, client): 6195 self.parent = client 6196 self.stub = ResourcesStub(channel) 6197 6198 def enumerate_tags(self, filter, *args, timeout=None): 6199 ''' 6200 EnumerateTags gets a list of the filter matching tags. 6201 ''' 6202 deadline = None if timeout is None else time.time() + timeout 6203 req = EnumerateTagsRequest() 6204 req.meta.CopyFrom(ListRequestMetadata()) 6205 if self.parent.page_limit > 0: 6206 req.meta.limit = self.parent.page_limit 6207 if self.parent.snapshot_datetime is not None: 6208 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6209 6210 req.filter = plumbing.quote_filter_args(filter, *args) 6211 6212 def generator(svc, req): 6213 tries = 0 6214 while True: 6215 t = None if deadline is None else deadline - time.time() 6216 try: 6217 plumbing_response = svc.stub.EnumerateTags( 6218 req, 6219 metadata=svc.parent.get_metadata( 6220 'Resources.EnumerateTags', req), 6221 timeout=t) 6222 except Exception as e: 6223 if self.parent.shouldRetry(tries, e, deadline): 6224 tries += 1 6225 time.sleep( 6226 self.parent.exponentialBackoff(tries, deadline)) 6227 continue 6228 raise plumbing.convert_error_to_porcelain(e) from e 6229 tries = 0 6230 for plumbing_item in plumbing_response.matches: 6231 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6232 if plumbing_response.meta.next_cursor == '': 6233 break 6234 req.meta.cursor = plumbing_response.meta.next_cursor 6235 6236 return generator(self, req) 6237 6238 def create(self, resource, timeout=None): 6239 ''' 6240 Create registers a new Resource. 6241 ''' 6242 deadline = None if timeout is None else time.time() + timeout 6243 req = ResourceCreateRequest() 6244 6245 if resource is not None: 6246 req.resource.CopyFrom( 6247 plumbing.convert_resource_to_plumbing(resource)) 6248 tries = 0 6249 plumbing_response = None 6250 while True: 6251 t = None if deadline is None else deadline - time.time() 6252 try: 6253 plumbing_response = self.stub.Create( 6254 req, 6255 metadata=self.parent.get_metadata('Resources.Create', req), 6256 timeout=t) 6257 except Exception as e: 6258 if self.parent.shouldRetry(tries, e, deadline): 6259 tries += 1 6260 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6261 continue 6262 raise plumbing.convert_error_to_porcelain(e) from e 6263 break 6264 6265 resp = models.ResourceCreateResponse() 6266 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6267 plumbing_response.meta) 6268 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6269 plumbing_response.rate_limit) 6270 resp.resource = plumbing.convert_resource_to_porcelain( 6271 plumbing_response.resource) 6272 return resp 6273 6274 def get(self, id, timeout=None): 6275 ''' 6276 Get reads one Resource by ID. 6277 ''' 6278 deadline = None if timeout is None else time.time() + timeout 6279 req = ResourceGetRequest() 6280 if self.parent.snapshot_datetime is not None: 6281 req.meta.CopyFrom(GetRequestMetadata()) 6282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6283 6284 req.id = (id) 6285 tries = 0 6286 plumbing_response = None 6287 while True: 6288 t = None if deadline is None else deadline - time.time() 6289 try: 6290 plumbing_response = self.stub.Get( 6291 req, 6292 metadata=self.parent.get_metadata('Resources.Get', req), 6293 timeout=t) 6294 except Exception as e: 6295 if self.parent.shouldRetry(tries, e, deadline): 6296 tries += 1 6297 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6298 continue 6299 raise plumbing.convert_error_to_porcelain(e) from e 6300 break 6301 6302 resp = models.ResourceGetResponse() 6303 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6304 plumbing_response.meta) 6305 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6306 plumbing_response.rate_limit) 6307 resp.resource = plumbing.convert_resource_to_porcelain( 6308 plumbing_response.resource) 6309 return resp 6310 6311 def update(self, resource, timeout=None): 6312 ''' 6313 Update replaces all the fields of a Resource by ID. 6314 ''' 6315 deadline = None if timeout is None else time.time() + timeout 6316 req = ResourceUpdateRequest() 6317 6318 if resource is not None: 6319 req.resource.CopyFrom( 6320 plumbing.convert_resource_to_plumbing(resource)) 6321 tries = 0 6322 plumbing_response = None 6323 while True: 6324 t = None if deadline is None else deadline - time.time() 6325 try: 6326 plumbing_response = self.stub.Update( 6327 req, 6328 metadata=self.parent.get_metadata('Resources.Update', req), 6329 timeout=t) 6330 except Exception as e: 6331 if self.parent.shouldRetry(tries, e, deadline): 6332 tries += 1 6333 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6334 continue 6335 raise plumbing.convert_error_to_porcelain(e) from e 6336 break 6337 6338 resp = models.ResourceUpdateResponse() 6339 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6340 plumbing_response.meta) 6341 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6342 plumbing_response.rate_limit) 6343 resp.resource = plumbing.convert_resource_to_porcelain( 6344 plumbing_response.resource) 6345 return resp 6346 6347 def delete(self, id, timeout=None): 6348 ''' 6349 Delete removes a Resource by ID. 6350 ''' 6351 deadline = None if timeout is None else time.time() + timeout 6352 req = ResourceDeleteRequest() 6353 6354 req.id = (id) 6355 tries = 0 6356 plumbing_response = None 6357 while True: 6358 t = None if deadline is None else deadline - time.time() 6359 try: 6360 plumbing_response = self.stub.Delete( 6361 req, 6362 metadata=self.parent.get_metadata('Resources.Delete', req), 6363 timeout=t) 6364 except Exception as e: 6365 if self.parent.shouldRetry(tries, e, deadline): 6366 tries += 1 6367 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6368 continue 6369 raise plumbing.convert_error_to_porcelain(e) from e 6370 break 6371 6372 resp = models.ResourceDeleteResponse() 6373 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6374 plumbing_response.meta) 6375 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6376 plumbing_response.rate_limit) 6377 return resp 6378 6379 def list(self, filter, *args, timeout=None): 6380 ''' 6381 List gets a list of Resources matching a given set of criteria. 6382 ''' 6383 deadline = None if timeout is None else time.time() + timeout 6384 req = ResourceListRequest() 6385 req.meta.CopyFrom(ListRequestMetadata()) 6386 if self.parent.page_limit > 0: 6387 req.meta.limit = self.parent.page_limit 6388 if self.parent.snapshot_datetime is not None: 6389 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6390 6391 req.filter = plumbing.quote_filter_args(filter, *args) 6392 6393 def generator(svc, req): 6394 tries = 0 6395 while True: 6396 t = None if deadline is None else deadline - time.time() 6397 try: 6398 plumbing_response = svc.stub.List( 6399 req, 6400 metadata=svc.parent.get_metadata( 6401 'Resources.List', req), 6402 timeout=t) 6403 except Exception as e: 6404 if self.parent.shouldRetry(tries, e, deadline): 6405 tries += 1 6406 time.sleep( 6407 self.parent.exponentialBackoff(tries, deadline)) 6408 continue 6409 raise plumbing.convert_error_to_porcelain(e) from e 6410 tries = 0 6411 for plumbing_item in plumbing_response.resources: 6412 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6413 if plumbing_response.meta.next_cursor == '': 6414 break 6415 req.meta.cursor = plumbing_response.meta.next_cursor 6416 6417 return generator(self, req) 6418 6419 def healthcheck(self, id, timeout=None): 6420 ''' 6421 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6422 large network of Nodes. The call will return immediately, and the updated health of the 6423 Resource can be retrieved via Get or List. 6424 ''' 6425 deadline = None if timeout is None else time.time() + timeout 6426 req = ResourceHealthcheckRequest() 6427 6428 req.id = (id) 6429 tries = 0 6430 plumbing_response = None 6431 while True: 6432 t = None if deadline is None else deadline - time.time() 6433 try: 6434 plumbing_response = self.stub.Healthcheck( 6435 req, 6436 metadata=self.parent.get_metadata('Resources.Healthcheck', 6437 req), 6438 timeout=t) 6439 except Exception as e: 6440 if self.parent.shouldRetry(tries, e, deadline): 6441 tries += 1 6442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6443 continue 6444 raise plumbing.convert_error_to_porcelain(e) from e 6445 break 6446 6447 resp = models.ResourceHealthcheckResponse() 6448 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6449 plumbing_response.meta) 6450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6451 plumbing_response.rate_limit) 6452 return resp 6453 6454 6455class SnapshotResources: 6456 ''' 6457 SnapshotResources exposes the read only methods of the Resources 6458 service for historical queries. 6459 ''' 6460 def __init__(self, resources): 6461 self.resources = resources 6462 6463 def get(self, id, timeout=None): 6464 ''' 6465 Get reads one Resource by ID. 6466 ''' 6467 return self.resources.get(id, timeout=timeout) 6468 6469 def list(self, filter, *args, timeout=None): 6470 ''' 6471 List gets a list of Resources matching a given set of criteria. 6472 ''' 6473 return self.resources.list(filter, *args, timeout=timeout) 6474 6475 6476class ResourcesHistory: 6477 ''' 6478 ResourcesHistory records all changes to the state of a Resource. 6479 See `strongdm.models.ResourceHistory`. 6480 ''' 6481 def __init__(self, channel, client): 6482 self.parent = client 6483 self.stub = ResourcesHistoryStub(channel) 6484 6485 def list(self, filter, *args, timeout=None): 6486 ''' 6487 List gets a list of ResourceHistory records matching a given set of criteria. 6488 ''' 6489 deadline = None if timeout is None else time.time() + timeout 6490 req = ResourceHistoryListRequest() 6491 req.meta.CopyFrom(ListRequestMetadata()) 6492 if self.parent.page_limit > 0: 6493 req.meta.limit = self.parent.page_limit 6494 if self.parent.snapshot_datetime is not None: 6495 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6496 6497 req.filter = plumbing.quote_filter_args(filter, *args) 6498 6499 def generator(svc, req): 6500 tries = 0 6501 while True: 6502 t = None if deadline is None else deadline - time.time() 6503 try: 6504 plumbing_response = svc.stub.List( 6505 req, 6506 metadata=svc.parent.get_metadata( 6507 'ResourcesHistory.List', req), 6508 timeout=t) 6509 except Exception as e: 6510 if self.parent.shouldRetry(tries, e, deadline): 6511 tries += 1 6512 time.sleep( 6513 self.parent.exponentialBackoff(tries, deadline)) 6514 continue 6515 raise plumbing.convert_error_to_porcelain(e) from e 6516 tries = 0 6517 for plumbing_item in plumbing_response.history: 6518 yield plumbing.convert_resource_history_to_porcelain( 6519 plumbing_item) 6520 if plumbing_response.meta.next_cursor == '': 6521 break 6522 req.meta.cursor = plumbing_response.meta.next_cursor 6523 6524 return generator(self, req) 6525 6526 6527class RoleResources: 6528 ''' 6529 RoleResources enumerates the resources to which roles have access. 6530 The RoleResources service is read-only. 6531 See `strongdm.models.RoleResource`. 6532 ''' 6533 def __init__(self, channel, client): 6534 self.parent = client 6535 self.stub = RoleResourcesStub(channel) 6536 6537 def list(self, filter, *args, timeout=None): 6538 ''' 6539 List gets a list of RoleResource records matching a given set of criteria. 6540 ''' 6541 deadline = None if timeout is None else time.time() + timeout 6542 req = RoleResourceListRequest() 6543 req.meta.CopyFrom(ListRequestMetadata()) 6544 if self.parent.page_limit > 0: 6545 req.meta.limit = self.parent.page_limit 6546 if self.parent.snapshot_datetime is not None: 6547 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6548 6549 req.filter = plumbing.quote_filter_args(filter, *args) 6550 6551 def generator(svc, req): 6552 tries = 0 6553 while True: 6554 t = None if deadline is None else deadline - time.time() 6555 try: 6556 plumbing_response = svc.stub.List( 6557 req, 6558 metadata=svc.parent.get_metadata( 6559 'RoleResources.List', req), 6560 timeout=t) 6561 except Exception as e: 6562 if self.parent.shouldRetry(tries, e, deadline): 6563 tries += 1 6564 time.sleep( 6565 self.parent.exponentialBackoff(tries, deadline)) 6566 continue 6567 raise plumbing.convert_error_to_porcelain(e) from e 6568 tries = 0 6569 for plumbing_item in plumbing_response.role_resources: 6570 yield plumbing.convert_role_resource_to_porcelain( 6571 plumbing_item) 6572 if plumbing_response.meta.next_cursor == '': 6573 break 6574 req.meta.cursor = plumbing_response.meta.next_cursor 6575 6576 return generator(self, req) 6577 6578 6579class SnapshotRoleResources: 6580 ''' 6581 SnapshotRoleResources exposes the read only methods of the RoleResources 6582 service for historical queries. 6583 ''' 6584 def __init__(self, role_resources): 6585 self.role_resources = role_resources 6586 6587 def list(self, filter, *args, timeout=None): 6588 ''' 6589 List gets a list of RoleResource records matching a given set of criteria. 6590 ''' 6591 return self.role_resources.list(filter, *args, timeout=timeout) 6592 6593 6594class RoleResourcesHistory: 6595 ''' 6596 RoleResourcesHistory records all changes to the state of a RoleResource. 6597 See `strongdm.models.RoleResourceHistory`. 6598 ''' 6599 def __init__(self, channel, client): 6600 self.parent = client 6601 self.stub = RoleResourcesHistoryStub(channel) 6602 6603 def list(self, filter, *args, timeout=None): 6604 ''' 6605 List gets a list of RoleResourceHistory records matching a given set of criteria. 6606 ''' 6607 deadline = None if timeout is None else time.time() + timeout 6608 req = RoleResourceHistoryListRequest() 6609 req.meta.CopyFrom(ListRequestMetadata()) 6610 if self.parent.page_limit > 0: 6611 req.meta.limit = self.parent.page_limit 6612 if self.parent.snapshot_datetime is not None: 6613 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6614 6615 req.filter = plumbing.quote_filter_args(filter, *args) 6616 6617 def generator(svc, req): 6618 tries = 0 6619 while True: 6620 t = None if deadline is None else deadline - time.time() 6621 try: 6622 plumbing_response = svc.stub.List( 6623 req, 6624 metadata=svc.parent.get_metadata( 6625 'RoleResourcesHistory.List', req), 6626 timeout=t) 6627 except Exception as e: 6628 if self.parent.shouldRetry(tries, e, deadline): 6629 tries += 1 6630 time.sleep( 6631 self.parent.exponentialBackoff(tries, deadline)) 6632 continue 6633 raise plumbing.convert_error_to_porcelain(e) from e 6634 tries = 0 6635 for plumbing_item in plumbing_response.history: 6636 yield plumbing.convert_role_resource_history_to_porcelain( 6637 plumbing_item) 6638 if plumbing_response.meta.next_cursor == '': 6639 break 6640 req.meta.cursor = plumbing_response.meta.next_cursor 6641 6642 return generator(self, req) 6643 6644 6645class RolesHistory: 6646 ''' 6647 RolesHistory records all changes to the state of a Role. 6648 See `strongdm.models.RoleHistory`. 6649 ''' 6650 def __init__(self, channel, client): 6651 self.parent = client 6652 self.stub = RolesHistoryStub(channel) 6653 6654 def list(self, filter, *args, timeout=None): 6655 ''' 6656 List gets a list of RoleHistory records matching a given set of criteria. 6657 ''' 6658 deadline = None if timeout is None else time.time() + timeout 6659 req = RoleHistoryListRequest() 6660 req.meta.CopyFrom(ListRequestMetadata()) 6661 if self.parent.page_limit > 0: 6662 req.meta.limit = self.parent.page_limit 6663 if self.parent.snapshot_datetime is not None: 6664 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6665 6666 req.filter = plumbing.quote_filter_args(filter, *args) 6667 6668 def generator(svc, req): 6669 tries = 0 6670 while True: 6671 t = None if deadline is None else deadline - time.time() 6672 try: 6673 plumbing_response = svc.stub.List( 6674 req, 6675 metadata=svc.parent.get_metadata( 6676 'RolesHistory.List', req), 6677 timeout=t) 6678 except Exception as e: 6679 if self.parent.shouldRetry(tries, e, deadline): 6680 tries += 1 6681 time.sleep( 6682 self.parent.exponentialBackoff(tries, deadline)) 6683 continue 6684 raise plumbing.convert_error_to_porcelain(e) from e 6685 tries = 0 6686 for plumbing_item in plumbing_response.history: 6687 yield plumbing.convert_role_history_to_porcelain( 6688 plumbing_item) 6689 if plumbing_response.meta.next_cursor == '': 6690 break 6691 req.meta.cursor = plumbing_response.meta.next_cursor 6692 6693 return generator(self, req) 6694 6695 6696class SecretStores: 6697 ''' 6698 SecretStores are servers where resource secrets (passwords, keys) are stored. 6699 See: 6700 `strongdm.models.ActiveDirectoryStore` 6701 `strongdm.models.AWSStore` 6702 `strongdm.models.AWSCertX509Store` 6703 `strongdm.models.AzureStore` 6704 `strongdm.models.CyberarkConjurStore` 6705 `strongdm.models.CyberarkPAMStore` 6706 `strongdm.models.CyberarkPAMExperimentalStore` 6707 `strongdm.models.DelineaStore` 6708 `strongdm.models.GCPStore` 6709 `strongdm.models.GCPCertX509Store` 6710 `strongdm.models.KeyfactorSSHStore` 6711 `strongdm.models.KeyfactorX509Store` 6712 `strongdm.models.VaultAppRoleStore` 6713 `strongdm.models.VaultAppRoleCertSSHStore` 6714 `strongdm.models.VaultAppRoleCertX509Store` 6715 `strongdm.models.VaultAWSEC2Store` 6716 `strongdm.models.VaultAWSEC2CertSSHStore` 6717 `strongdm.models.VaultAWSEC2CertX509Store` 6718 `strongdm.models.VaultAWSIAMStore` 6719 `strongdm.models.VaultAWSIAMCertSSHStore` 6720 `strongdm.models.VaultAWSIAMCertX509Store` 6721 `strongdm.models.VaultTLSStore` 6722 `strongdm.models.VaultTLSCertSSHStore` 6723 `strongdm.models.VaultTLSCertX509Store` 6724 `strongdm.models.VaultTokenStore` 6725 `strongdm.models.VaultTokenCertSSHStore` 6726 `strongdm.models.VaultTokenCertX509Store` 6727 ''' 6728 def __init__(self, channel, client): 6729 self.parent = client 6730 self.stub = SecretStoresStub(channel) 6731 6732 def create(self, secret_store, timeout=None): 6733 deadline = None if timeout is None else time.time() + timeout 6734 req = SecretStoreCreateRequest() 6735 6736 if secret_store is not None: 6737 req.secret_store.CopyFrom( 6738 plumbing.convert_secret_store_to_plumbing(secret_store)) 6739 tries = 0 6740 plumbing_response = None 6741 while True: 6742 t = None if deadline is None else deadline - time.time() 6743 try: 6744 plumbing_response = self.stub.Create( 6745 req, 6746 metadata=self.parent.get_metadata('SecretStores.Create', 6747 req), 6748 timeout=t) 6749 except Exception as e: 6750 if self.parent.shouldRetry(tries, e, deadline): 6751 tries += 1 6752 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6753 continue 6754 raise plumbing.convert_error_to_porcelain(e) from e 6755 break 6756 6757 resp = models.SecretStoreCreateResponse() 6758 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6759 plumbing_response.meta) 6760 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6761 plumbing_response.rate_limit) 6762 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6763 plumbing_response.secret_store) 6764 return resp 6765 6766 def get(self, id, timeout=None): 6767 ''' 6768 Get reads one SecretStore by ID. 6769 ''' 6770 deadline = None if timeout is None else time.time() + timeout 6771 req = SecretStoreGetRequest() 6772 if self.parent.snapshot_datetime is not None: 6773 req.meta.CopyFrom(GetRequestMetadata()) 6774 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6775 6776 req.id = (id) 6777 tries = 0 6778 plumbing_response = None 6779 while True: 6780 t = None if deadline is None else deadline - time.time() 6781 try: 6782 plumbing_response = self.stub.Get( 6783 req, 6784 metadata=self.parent.get_metadata('SecretStores.Get', req), 6785 timeout=t) 6786 except Exception as e: 6787 if self.parent.shouldRetry(tries, e, deadline): 6788 tries += 1 6789 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6790 continue 6791 raise plumbing.convert_error_to_porcelain(e) from e 6792 break 6793 6794 resp = models.SecretStoreGetResponse() 6795 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6796 plumbing_response.meta) 6797 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6798 plumbing_response.rate_limit) 6799 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6800 plumbing_response.secret_store) 6801 return resp 6802 6803 def update(self, secret_store, timeout=None): 6804 ''' 6805 Update replaces all the fields of a SecretStore by ID. 6806 ''' 6807 deadline = None if timeout is None else time.time() + timeout 6808 req = SecretStoreUpdateRequest() 6809 6810 if secret_store is not None: 6811 req.secret_store.CopyFrom( 6812 plumbing.convert_secret_store_to_plumbing(secret_store)) 6813 tries = 0 6814 plumbing_response = None 6815 while True: 6816 t = None if deadline is None else deadline - time.time() 6817 try: 6818 plumbing_response = self.stub.Update( 6819 req, 6820 metadata=self.parent.get_metadata('SecretStores.Update', 6821 req), 6822 timeout=t) 6823 except Exception as e: 6824 if self.parent.shouldRetry(tries, e, deadline): 6825 tries += 1 6826 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6827 continue 6828 raise plumbing.convert_error_to_porcelain(e) from e 6829 break 6830 6831 resp = models.SecretStoreUpdateResponse() 6832 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6833 plumbing_response.meta) 6834 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6835 plumbing_response.rate_limit) 6836 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6837 plumbing_response.secret_store) 6838 return resp 6839 6840 def delete(self, id, timeout=None): 6841 ''' 6842 Delete removes a SecretStore by ID. 6843 ''' 6844 deadline = None if timeout is None else time.time() + timeout 6845 req = SecretStoreDeleteRequest() 6846 6847 req.id = (id) 6848 tries = 0 6849 plumbing_response = None 6850 while True: 6851 t = None if deadline is None else deadline - time.time() 6852 try: 6853 plumbing_response = self.stub.Delete( 6854 req, 6855 metadata=self.parent.get_metadata('SecretStores.Delete', 6856 req), 6857 timeout=t) 6858 except Exception as e: 6859 if self.parent.shouldRetry(tries, e, deadline): 6860 tries += 1 6861 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6862 continue 6863 raise plumbing.convert_error_to_porcelain(e) from e 6864 break 6865 6866 resp = models.SecretStoreDeleteResponse() 6867 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6868 plumbing_response.meta) 6869 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6870 plumbing_response.rate_limit) 6871 return resp 6872 6873 def list(self, filter, *args, timeout=None): 6874 ''' 6875 List gets a list of SecretStores matching a given set of criteria. 6876 ''' 6877 deadline = None if timeout is None else time.time() + timeout 6878 req = SecretStoreListRequest() 6879 req.meta.CopyFrom(ListRequestMetadata()) 6880 if self.parent.page_limit > 0: 6881 req.meta.limit = self.parent.page_limit 6882 if self.parent.snapshot_datetime is not None: 6883 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6884 6885 req.filter = plumbing.quote_filter_args(filter, *args) 6886 6887 def generator(svc, req): 6888 tries = 0 6889 while True: 6890 t = None if deadline is None else deadline - time.time() 6891 try: 6892 plumbing_response = svc.stub.List( 6893 req, 6894 metadata=svc.parent.get_metadata( 6895 'SecretStores.List', req), 6896 timeout=t) 6897 except Exception as e: 6898 if self.parent.shouldRetry(tries, e, deadline): 6899 tries += 1 6900 time.sleep( 6901 self.parent.exponentialBackoff(tries, deadline)) 6902 continue 6903 raise plumbing.convert_error_to_porcelain(e) from e 6904 tries = 0 6905 for plumbing_item in plumbing_response.secret_stores: 6906 yield plumbing.convert_secret_store_to_porcelain( 6907 plumbing_item) 6908 if plumbing_response.meta.next_cursor == '': 6909 break 6910 req.meta.cursor = plumbing_response.meta.next_cursor 6911 6912 return generator(self, req) 6913 6914 6915class SnapshotSecretStores: 6916 ''' 6917 SnapshotSecretStores exposes the read only methods of the SecretStores 6918 service for historical queries. 6919 ''' 6920 def __init__(self, secret_stores): 6921 self.secret_stores = secret_stores 6922 6923 def get(self, id, timeout=None): 6924 ''' 6925 Get reads one SecretStore by ID. 6926 ''' 6927 return self.secret_stores.get(id, timeout=timeout) 6928 6929 def list(self, filter, *args, timeout=None): 6930 ''' 6931 List gets a list of SecretStores matching a given set of criteria. 6932 ''' 6933 return self.secret_stores.list(filter, *args, timeout=timeout) 6934 6935 6936class SecretEngines: 6937 ''' 6938 6939 See: 6940 `strongdm.models.ActiveDirectoryEngine` 6941 `strongdm.models.KeyValueEngine` 6942 `strongdm.models.PostgresEngine` 6943 ''' 6944 def __init__(self, channel, client): 6945 self.parent = client 6946 self.stub = SecretEnginesStub(channel) 6947 6948 def list(self, filter, *args, timeout=None): 6949 ''' 6950 List returns a list of Secret Engines 6951 ''' 6952 deadline = None if timeout is None else time.time() + timeout 6953 req = SecretEngineListRequest() 6954 req.meta.CopyFrom(ListRequestMetadata()) 6955 if self.parent.page_limit > 0: 6956 req.meta.limit = self.parent.page_limit 6957 if self.parent.snapshot_datetime is not None: 6958 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6959 6960 req.filter = plumbing.quote_filter_args(filter, *args) 6961 6962 def generator(svc, req): 6963 tries = 0 6964 while True: 6965 t = None if deadline is None else deadline - time.time() 6966 try: 6967 plumbing_response = svc.stub.List( 6968 req, 6969 metadata=svc.parent.get_metadata( 6970 'SecretEngines.List', req), 6971 timeout=t) 6972 except Exception as e: 6973 if self.parent.shouldRetry(tries, e, deadline): 6974 tries += 1 6975 time.sleep( 6976 self.parent.exponentialBackoff(tries, deadline)) 6977 continue 6978 raise plumbing.convert_error_to_porcelain(e) from e 6979 tries = 0 6980 for plumbing_item in plumbing_response.secret_engines: 6981 yield plumbing.convert_secret_engine_to_porcelain( 6982 plumbing_item) 6983 if plumbing_response.meta.next_cursor == '': 6984 break 6985 req.meta.cursor = plumbing_response.meta.next_cursor 6986 6987 return generator(self, req) 6988 6989 def get(self, id, timeout=None): 6990 ''' 6991 Get returns a secret engine details 6992 ''' 6993 deadline = None if timeout is None else time.time() + timeout 6994 req = SecretEngineGetRequest() 6995 if self.parent.snapshot_datetime is not None: 6996 req.meta.CopyFrom(GetRequestMetadata()) 6997 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6998 6999 req.id = (id) 7000 tries = 0 7001 plumbing_response = None 7002 while True: 7003 t = None if deadline is None else deadline - time.time() 7004 try: 7005 plumbing_response = self.stub.Get( 7006 req, 7007 metadata=self.parent.get_metadata('SecretEngines.Get', 7008 req), 7009 timeout=t) 7010 except Exception as e: 7011 if self.parent.shouldRetry(tries, e, deadline): 7012 tries += 1 7013 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7014 continue 7015 raise plumbing.convert_error_to_porcelain(e) from e 7016 break 7017 7018 resp = models.SecretEngineGetResponse() 7019 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7020 plumbing_response.meta) 7021 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7022 plumbing_response.rate_limit) 7023 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7024 plumbing_response.secret_engine) 7025 return resp 7026 7027 def create(self, secret_engine, timeout=None): 7028 ''' 7029 Create creates a secret engine 7030 ''' 7031 deadline = None if timeout is None else time.time() + timeout 7032 req = SecretEngineCreateRequest() 7033 7034 if secret_engine is not None: 7035 req.secret_engine.CopyFrom( 7036 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7037 tries = 0 7038 plumbing_response = None 7039 while True: 7040 t = None if deadline is None else deadline - time.time() 7041 try: 7042 plumbing_response = self.stub.Create( 7043 req, 7044 metadata=self.parent.get_metadata('SecretEngines.Create', 7045 req), 7046 timeout=t) 7047 except Exception as e: 7048 if self.parent.shouldRetry(tries, e, deadline): 7049 tries += 1 7050 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7051 continue 7052 raise plumbing.convert_error_to_porcelain(e) from e 7053 break 7054 7055 resp = models.SecretEngineCreateResponse() 7056 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7057 plumbing_response.meta) 7058 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7059 plumbing_response.rate_limit) 7060 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7061 plumbing_response.secret_engine) 7062 return resp 7063 7064 def update(self, secret_engine, timeout=None): 7065 ''' 7066 Update updates a secret engine 7067 ''' 7068 deadline = None if timeout is None else time.time() + timeout 7069 req = SecretEngineUpdateRequest() 7070 7071 if secret_engine is not None: 7072 req.secret_engine.CopyFrom( 7073 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7074 tries = 0 7075 plumbing_response = None 7076 while True: 7077 t = None if deadline is None else deadline - time.time() 7078 try: 7079 plumbing_response = self.stub.Update( 7080 req, 7081 metadata=self.parent.get_metadata('SecretEngines.Update', 7082 req), 7083 timeout=t) 7084 except Exception as e: 7085 if self.parent.shouldRetry(tries, e, deadline): 7086 tries += 1 7087 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7088 continue 7089 raise plumbing.convert_error_to_porcelain(e) from e 7090 break 7091 7092 resp = models.SecretEngineUpdateResponse() 7093 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7094 plumbing_response.meta) 7095 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7096 plumbing_response.rate_limit) 7097 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7098 plumbing_response.secret_engine) 7099 return resp 7100 7101 def delete(self, id, timeout=None): 7102 ''' 7103 Delete deletes a secret engine 7104 ''' 7105 deadline = None if timeout is None else time.time() + timeout 7106 req = SecretEngineDeleteRequest() 7107 7108 req.id = (id) 7109 tries = 0 7110 plumbing_response = None 7111 while True: 7112 t = None if deadline is None else deadline - time.time() 7113 try: 7114 plumbing_response = self.stub.Delete( 7115 req, 7116 metadata=self.parent.get_metadata('SecretEngines.Delete', 7117 req), 7118 timeout=t) 7119 except Exception as e: 7120 if self.parent.shouldRetry(tries, e, deadline): 7121 tries += 1 7122 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7123 continue 7124 raise plumbing.convert_error_to_porcelain(e) from e 7125 break 7126 7127 resp = models.SecretEngineDeleteResponse() 7128 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7129 plumbing_response.rate_limit) 7130 return resp 7131 7132 def list_secret_stores(self, filter, *args, timeout=None): 7133 ''' 7134 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7135 for Secret Engine 7136 ''' 7137 deadline = None if timeout is None else time.time() + timeout 7138 req = SecretStoreListRequest() 7139 req.meta.CopyFrom(ListRequestMetadata()) 7140 if self.parent.page_limit > 0: 7141 req.meta.limit = self.parent.page_limit 7142 if self.parent.snapshot_datetime is not None: 7143 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7144 7145 req.filter = plumbing.quote_filter_args(filter, *args) 7146 7147 def generator(svc, req): 7148 tries = 0 7149 while True: 7150 t = None if deadline is None else deadline - time.time() 7151 try: 7152 plumbing_response = svc.stub.ListSecretStores( 7153 req, 7154 metadata=svc.parent.get_metadata( 7155 'SecretEngines.ListSecretStores', req), 7156 timeout=t) 7157 except Exception as e: 7158 if self.parent.shouldRetry(tries, e, deadline): 7159 tries += 1 7160 time.sleep( 7161 self.parent.exponentialBackoff(tries, deadline)) 7162 continue 7163 raise plumbing.convert_error_to_porcelain(e) from e 7164 tries = 0 7165 for plumbing_item in plumbing_response.secret_stores: 7166 yield plumbing.convert_secret_store_to_porcelain( 7167 plumbing_item) 7168 if plumbing_response.meta.next_cursor == '': 7169 break 7170 req.meta.cursor = plumbing_response.meta.next_cursor 7171 7172 return generator(self, req) 7173 7174 def generate_keys(self, secret_engine_id, timeout=None): 7175 ''' 7176 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7177 ''' 7178 deadline = None if timeout is None else time.time() + timeout 7179 req = GenerateKeysRequest() 7180 7181 req.secret_engine_id = (secret_engine_id) 7182 tries = 0 7183 plumbing_response = None 7184 while True: 7185 t = None if deadline is None else deadline - time.time() 7186 try: 7187 plumbing_response = self.stub.GenerateKeys( 7188 req, 7189 metadata=self.parent.get_metadata( 7190 'SecretEngines.GenerateKeys', req), 7191 timeout=t) 7192 except Exception as e: 7193 if self.parent.shouldRetry(tries, e, deadline): 7194 tries += 1 7195 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7196 continue 7197 raise plumbing.convert_error_to_porcelain(e) from e 7198 break 7199 7200 resp = models.GenerateKeysResponse() 7201 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7202 plumbing_response.rate_limit) 7203 return resp 7204 7205 def healthcheck(self, secret_engine_id, timeout=None): 7206 ''' 7207 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7208 ''' 7209 deadline = None if timeout is None else time.time() + timeout 7210 req = HealthcheckRequest() 7211 7212 req.secret_engine_id = (secret_engine_id) 7213 tries = 0 7214 plumbing_response = None 7215 while True: 7216 t = None if deadline is None else deadline - time.time() 7217 try: 7218 plumbing_response = self.stub.Healthcheck( 7219 req, 7220 metadata=self.parent.get_metadata( 7221 'SecretEngines.Healthcheck', req), 7222 timeout=t) 7223 except Exception as e: 7224 if self.parent.shouldRetry(tries, e, deadline): 7225 tries += 1 7226 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7227 continue 7228 raise plumbing.convert_error_to_porcelain(e) from e 7229 break 7230 7231 resp = models.HealthcheckResponse() 7232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7233 plumbing_response.rate_limit) 7234 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7235 plumbing_response.status) 7236 return resp 7237 7238 def rotate(self, id, password_policy, timeout=None): 7239 ''' 7240 Rotate rotates secret engine's credentials 7241 ''' 7242 deadline = None if timeout is None else time.time() + timeout 7243 req = SecretEngineRotateRequest() 7244 7245 req.id = (id) 7246 if password_policy is not None: 7247 req.password_policy.CopyFrom( 7248 plumbing.convert_secret_engine_password_policy_to_plumbing( 7249 password_policy)) 7250 tries = 0 7251 plumbing_response = None 7252 while True: 7253 t = None if deadline is None else deadline - time.time() 7254 try: 7255 plumbing_response = self.stub.Rotate( 7256 req, 7257 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7258 req), 7259 timeout=t) 7260 except Exception as e: 7261 if self.parent.shouldRetry(tries, e, deadline): 7262 tries += 1 7263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7264 continue 7265 raise plumbing.convert_error_to_porcelain(e) from e 7266 break 7267 7268 resp = models.SecretEngineRotateResponse() 7269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7270 plumbing_response.rate_limit) 7271 return resp 7272 7273 7274class SecretStoreHealths: 7275 ''' 7276 SecretStoreHealths exposes health states for secret stores. 7277 See `strongdm.models.SecretStoreHealth`. 7278 ''' 7279 def __init__(self, channel, client): 7280 self.parent = client 7281 self.stub = SecretStoreHealthsStub(channel) 7282 7283 def list(self, filter, *args, timeout=None): 7284 ''' 7285 List reports the health status of node to secret store pairs. 7286 ''' 7287 deadline = None if timeout is None else time.time() + timeout 7288 req = SecretStoreHealthListRequest() 7289 req.meta.CopyFrom(ListRequestMetadata()) 7290 if self.parent.page_limit > 0: 7291 req.meta.limit = self.parent.page_limit 7292 if self.parent.snapshot_datetime is not None: 7293 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7294 7295 req.filter = plumbing.quote_filter_args(filter, *args) 7296 7297 def generator(svc, req): 7298 tries = 0 7299 while True: 7300 t = None if deadline is None else deadline - time.time() 7301 try: 7302 plumbing_response = svc.stub.List( 7303 req, 7304 metadata=svc.parent.get_metadata( 7305 'SecretStoreHealths.List', req), 7306 timeout=t) 7307 except Exception as e: 7308 if self.parent.shouldRetry(tries, e, deadline): 7309 tries += 1 7310 time.sleep( 7311 self.parent.exponentialBackoff(tries, deadline)) 7312 continue 7313 raise plumbing.convert_error_to_porcelain(e) from e 7314 tries = 0 7315 for plumbing_item in plumbing_response.secret_store_healths: 7316 yield plumbing.convert_secret_store_health_to_porcelain( 7317 plumbing_item) 7318 if plumbing_response.meta.next_cursor == '': 7319 break 7320 req.meta.cursor = plumbing_response.meta.next_cursor 7321 7322 return generator(self, req) 7323 7324 def healthcheck(self, secret_store_id, timeout=None): 7325 ''' 7326 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7327 to propagate across a large network of Nodes. The call will return immediately, and the 7328 updated health of the Secret Store can be retrieved via List. 7329 ''' 7330 deadline = None if timeout is None else time.time() + timeout 7331 req = SecretStoreHealthcheckRequest() 7332 7333 req.secret_store_id = (secret_store_id) 7334 tries = 0 7335 plumbing_response = None 7336 while True: 7337 t = None if deadline is None else deadline - time.time() 7338 try: 7339 plumbing_response = self.stub.Healthcheck( 7340 req, 7341 metadata=self.parent.get_metadata( 7342 'SecretStoreHealths.Healthcheck', req), 7343 timeout=t) 7344 except Exception as e: 7345 if self.parent.shouldRetry(tries, e, deadline): 7346 tries += 1 7347 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7348 continue 7349 raise plumbing.convert_error_to_porcelain(e) from e 7350 break 7351 7352 resp = models.SecretStoreHealthcheckResponse() 7353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7354 plumbing_response.rate_limit) 7355 return resp 7356 7357 7358class SecretStoresHistory: 7359 ''' 7360 SecretStoresHistory records all changes to the state of a SecretStore. 7361 See `strongdm.models.SecretStoreHistory`. 7362 ''' 7363 def __init__(self, channel, client): 7364 self.parent = client 7365 self.stub = SecretStoresHistoryStub(channel) 7366 7367 def list(self, filter, *args, timeout=None): 7368 ''' 7369 List gets a list of SecretStoreHistory records matching a given set of criteria. 7370 ''' 7371 deadline = None if timeout is None else time.time() + timeout 7372 req = SecretStoreHistoryListRequest() 7373 req.meta.CopyFrom(ListRequestMetadata()) 7374 if self.parent.page_limit > 0: 7375 req.meta.limit = self.parent.page_limit 7376 if self.parent.snapshot_datetime is not None: 7377 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7378 7379 req.filter = plumbing.quote_filter_args(filter, *args) 7380 7381 def generator(svc, req): 7382 tries = 0 7383 while True: 7384 t = None if deadline is None else deadline - time.time() 7385 try: 7386 plumbing_response = svc.stub.List( 7387 req, 7388 metadata=svc.parent.get_metadata( 7389 'SecretStoresHistory.List', req), 7390 timeout=t) 7391 except Exception as e: 7392 if self.parent.shouldRetry(tries, e, deadline): 7393 tries += 1 7394 time.sleep( 7395 self.parent.exponentialBackoff(tries, deadline)) 7396 continue 7397 raise plumbing.convert_error_to_porcelain(e) from e 7398 tries = 0 7399 for plumbing_item in plumbing_response.history: 7400 yield plumbing.convert_secret_store_history_to_porcelain( 7401 plumbing_item) 7402 if plumbing_response.meta.next_cursor == '': 7403 break 7404 req.meta.cursor = plumbing_response.meta.next_cursor 7405 7406 return generator(self, req) 7407 7408 7409class WorkflowApprovers: 7410 ''' 7411 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7412 See `strongdm.models.WorkflowApprover`. 7413 ''' 7414 def __init__(self, channel, client): 7415 self.parent = client 7416 self.stub = WorkflowApproversStub(channel) 7417 7418 def create(self, workflow_approver, timeout=None): 7419 ''' 7420 Create creates a new workflow approver 7421 ''' 7422 deadline = None if timeout is None else time.time() + timeout 7423 req = WorkflowApproversCreateRequest() 7424 7425 if workflow_approver is not None: 7426 req.workflow_approver.CopyFrom( 7427 plumbing.convert_workflow_approver_to_plumbing( 7428 workflow_approver)) 7429 tries = 0 7430 plumbing_response = None 7431 while True: 7432 t = None if deadline is None else deadline - time.time() 7433 try: 7434 plumbing_response = self.stub.Create( 7435 req, 7436 metadata=self.parent.get_metadata( 7437 'WorkflowApprovers.Create', req), 7438 timeout=t) 7439 except Exception as e: 7440 if self.parent.shouldRetry(tries, e, deadline): 7441 tries += 1 7442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7443 continue 7444 raise plumbing.convert_error_to_porcelain(e) from e 7445 break 7446 7447 resp = models.WorkflowApproversCreateResponse() 7448 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7449 plumbing_response.rate_limit) 7450 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7451 plumbing_response.workflow_approver) 7452 return resp 7453 7454 def get(self, id, timeout=None): 7455 ''' 7456 Get reads one workflow approver by ID. 7457 ''' 7458 deadline = None if timeout is None else time.time() + timeout 7459 req = WorkflowApproverGetRequest() 7460 if self.parent.snapshot_datetime is not None: 7461 req.meta.CopyFrom(GetRequestMetadata()) 7462 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7463 7464 req.id = (id) 7465 tries = 0 7466 plumbing_response = None 7467 while True: 7468 t = None if deadline is None else deadline - time.time() 7469 try: 7470 plumbing_response = self.stub.Get( 7471 req, 7472 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7473 req), 7474 timeout=t) 7475 except Exception as e: 7476 if self.parent.shouldRetry(tries, e, deadline): 7477 tries += 1 7478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7479 continue 7480 raise plumbing.convert_error_to_porcelain(e) from e 7481 break 7482 7483 resp = models.WorkflowApproverGetResponse() 7484 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7485 plumbing_response.meta) 7486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7487 plumbing_response.rate_limit) 7488 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7489 plumbing_response.workflow_approver) 7490 return resp 7491 7492 def delete(self, id, timeout=None): 7493 ''' 7494 Delete deletes a workflow approver 7495 ''' 7496 deadline = None if timeout is None else time.time() + timeout 7497 req = WorkflowApproversDeleteRequest() 7498 7499 req.id = (id) 7500 tries = 0 7501 plumbing_response = None 7502 while True: 7503 t = None if deadline is None else deadline - time.time() 7504 try: 7505 plumbing_response = self.stub.Delete( 7506 req, 7507 metadata=self.parent.get_metadata( 7508 'WorkflowApprovers.Delete', req), 7509 timeout=t) 7510 except Exception as e: 7511 if self.parent.shouldRetry(tries, e, deadline): 7512 tries += 1 7513 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7514 continue 7515 raise plumbing.convert_error_to_porcelain(e) from e 7516 break 7517 7518 resp = models.WorkflowApproversDeleteResponse() 7519 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7520 plumbing_response.rate_limit) 7521 return resp 7522 7523 def list(self, filter, *args, timeout=None): 7524 ''' 7525 Lists existing workflow approvers. 7526 ''' 7527 deadline = None if timeout is None else time.time() + timeout 7528 req = WorkflowApproversListRequest() 7529 req.meta.CopyFrom(ListRequestMetadata()) 7530 if self.parent.page_limit > 0: 7531 req.meta.limit = self.parent.page_limit 7532 if self.parent.snapshot_datetime is not None: 7533 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7534 7535 req.filter = plumbing.quote_filter_args(filter, *args) 7536 7537 def generator(svc, req): 7538 tries = 0 7539 while True: 7540 t = None if deadline is None else deadline - time.time() 7541 try: 7542 plumbing_response = svc.stub.List( 7543 req, 7544 metadata=svc.parent.get_metadata( 7545 'WorkflowApprovers.List', req), 7546 timeout=t) 7547 except Exception as e: 7548 if self.parent.shouldRetry(tries, e, deadline): 7549 tries += 1 7550 time.sleep( 7551 self.parent.exponentialBackoff(tries, deadline)) 7552 continue 7553 raise plumbing.convert_error_to_porcelain(e) from e 7554 tries = 0 7555 for plumbing_item in plumbing_response.workflow_approvers: 7556 yield plumbing.convert_workflow_approver_to_porcelain( 7557 plumbing_item) 7558 if plumbing_response.meta.next_cursor == '': 7559 break 7560 req.meta.cursor = plumbing_response.meta.next_cursor 7561 7562 return generator(self, req) 7563 7564 7565class SnapshotWorkflowApprovers: 7566 ''' 7567 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7568 service for historical queries. 7569 ''' 7570 def __init__(self, workflow_approvers): 7571 self.workflow_approvers = workflow_approvers 7572 7573 def get(self, id, timeout=None): 7574 ''' 7575 Get reads one workflow approver by ID. 7576 ''' 7577 return self.workflow_approvers.get(id, timeout=timeout) 7578 7579 def list(self, filter, *args, timeout=None): 7580 ''' 7581 Lists existing workflow approvers. 7582 ''' 7583 return self.workflow_approvers.list(filter, *args, timeout=timeout) 7584 7585 7586class WorkflowApproversHistory: 7587 ''' 7588 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7589 See `strongdm.models.WorkflowApproverHistory`. 7590 ''' 7591 def __init__(self, channel, client): 7592 self.parent = client 7593 self.stub = WorkflowApproversHistoryStub(channel) 7594 7595 def list(self, filter, *args, timeout=None): 7596 ''' 7597 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7598 ''' 7599 deadline = None if timeout is None else time.time() + timeout 7600 req = WorkflowApproversHistoryListRequest() 7601 req.meta.CopyFrom(ListRequestMetadata()) 7602 if self.parent.page_limit > 0: 7603 req.meta.limit = self.parent.page_limit 7604 if self.parent.snapshot_datetime is not None: 7605 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7606 7607 req.filter = plumbing.quote_filter_args(filter, *args) 7608 7609 def generator(svc, req): 7610 tries = 0 7611 while True: 7612 t = None if deadline is None else deadline - time.time() 7613 try: 7614 plumbing_response = svc.stub.List( 7615 req, 7616 metadata=svc.parent.get_metadata( 7617 'WorkflowApproversHistory.List', req), 7618 timeout=t) 7619 except Exception as e: 7620 if self.parent.shouldRetry(tries, e, deadline): 7621 tries += 1 7622 time.sleep( 7623 self.parent.exponentialBackoff(tries, deadline)) 7624 continue 7625 raise plumbing.convert_error_to_porcelain(e) from e 7626 tries = 0 7627 for plumbing_item in plumbing_response.history: 7628 yield plumbing.convert_workflow_approver_history_to_porcelain( 7629 plumbing_item) 7630 if plumbing_response.meta.next_cursor == '': 7631 break 7632 req.meta.cursor = plumbing_response.meta.next_cursor 7633 7634 return generator(self, req) 7635 7636 7637class WorkflowRoles: 7638 ''' 7639 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7640 to request access to a resource via the workflow. 7641 See `strongdm.models.WorkflowRole`. 7642 ''' 7643 def __init__(self, channel, client): 7644 self.parent = client 7645 self.stub = WorkflowRolesStub(channel) 7646 7647 def create(self, workflow_role, timeout=None): 7648 ''' 7649 Create creates a new workflow role 7650 ''' 7651 deadline = None if timeout is None else time.time() + timeout 7652 req = WorkflowRolesCreateRequest() 7653 7654 if workflow_role is not None: 7655 req.workflow_role.CopyFrom( 7656 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7657 tries = 0 7658 plumbing_response = None 7659 while True: 7660 t = None if deadline is None else deadline - time.time() 7661 try: 7662 plumbing_response = self.stub.Create( 7663 req, 7664 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7665 req), 7666 timeout=t) 7667 except Exception as e: 7668 if self.parent.shouldRetry(tries, e, deadline): 7669 tries += 1 7670 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7671 continue 7672 raise plumbing.convert_error_to_porcelain(e) from e 7673 break 7674 7675 resp = models.WorkflowRolesCreateResponse() 7676 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7677 plumbing_response.rate_limit) 7678 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7679 plumbing_response.workflow_role) 7680 return resp 7681 7682 def get(self, id, timeout=None): 7683 ''' 7684 Get reads one workflow role by ID. 7685 ''' 7686 deadline = None if timeout is None else time.time() + timeout 7687 req = WorkflowRoleGetRequest() 7688 if self.parent.snapshot_datetime is not None: 7689 req.meta.CopyFrom(GetRequestMetadata()) 7690 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7691 7692 req.id = (id) 7693 tries = 0 7694 plumbing_response = None 7695 while True: 7696 t = None if deadline is None else deadline - time.time() 7697 try: 7698 plumbing_response = self.stub.Get( 7699 req, 7700 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7701 req), 7702 timeout=t) 7703 except Exception as e: 7704 if self.parent.shouldRetry(tries, e, deadline): 7705 tries += 1 7706 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7707 continue 7708 raise plumbing.convert_error_to_porcelain(e) from e 7709 break 7710 7711 resp = models.WorkflowRoleGetResponse() 7712 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7713 plumbing_response.meta) 7714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7715 plumbing_response.rate_limit) 7716 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7717 plumbing_response.workflow_role) 7718 return resp 7719 7720 def delete(self, id, timeout=None): 7721 ''' 7722 Delete deletes a workflow role 7723 ''' 7724 deadline = None if timeout is None else time.time() + timeout 7725 req = WorkflowRolesDeleteRequest() 7726 7727 req.id = (id) 7728 tries = 0 7729 plumbing_response = None 7730 while True: 7731 t = None if deadline is None else deadline - time.time() 7732 try: 7733 plumbing_response = self.stub.Delete( 7734 req, 7735 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7736 req), 7737 timeout=t) 7738 except Exception as e: 7739 if self.parent.shouldRetry(tries, e, deadline): 7740 tries += 1 7741 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7742 continue 7743 raise plumbing.convert_error_to_porcelain(e) from e 7744 break 7745 7746 resp = models.WorkflowRolesDeleteResponse() 7747 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7748 plumbing_response.rate_limit) 7749 return resp 7750 7751 def list(self, filter, *args, timeout=None): 7752 ''' 7753 Lists existing workflow roles. 7754 ''' 7755 deadline = None if timeout is None else time.time() + timeout 7756 req = WorkflowRolesListRequest() 7757 req.meta.CopyFrom(ListRequestMetadata()) 7758 if self.parent.page_limit > 0: 7759 req.meta.limit = self.parent.page_limit 7760 if self.parent.snapshot_datetime is not None: 7761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7762 7763 req.filter = plumbing.quote_filter_args(filter, *args) 7764 7765 def generator(svc, req): 7766 tries = 0 7767 while True: 7768 t = None if deadline is None else deadline - time.time() 7769 try: 7770 plumbing_response = svc.stub.List( 7771 req, 7772 metadata=svc.parent.get_metadata( 7773 'WorkflowRoles.List', req), 7774 timeout=t) 7775 except Exception as e: 7776 if self.parent.shouldRetry(tries, e, deadline): 7777 tries += 1 7778 time.sleep( 7779 self.parent.exponentialBackoff(tries, deadline)) 7780 continue 7781 raise plumbing.convert_error_to_porcelain(e) from e 7782 tries = 0 7783 for plumbing_item in plumbing_response.workflow_role: 7784 yield plumbing.convert_workflow_role_to_porcelain( 7785 plumbing_item) 7786 if plumbing_response.meta.next_cursor == '': 7787 break 7788 req.meta.cursor = plumbing_response.meta.next_cursor 7789 7790 return generator(self, req) 7791 7792 7793class SnapshotWorkflowRoles: 7794 ''' 7795 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7796 service for historical queries. 7797 ''' 7798 def __init__(self, workflow_roles): 7799 self.workflow_roles = workflow_roles 7800 7801 def get(self, id, timeout=None): 7802 ''' 7803 Get reads one workflow role by ID. 7804 ''' 7805 return self.workflow_roles.get(id, timeout=timeout) 7806 7807 def list(self, filter, *args, timeout=None): 7808 ''' 7809 Lists existing workflow roles. 7810 ''' 7811 return self.workflow_roles.list(filter, *args, timeout=timeout) 7812 7813 7814class WorkflowRolesHistory: 7815 ''' 7816 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7817 See `strongdm.models.WorkflowRoleHistory`. 7818 ''' 7819 def __init__(self, channel, client): 7820 self.parent = client 7821 self.stub = WorkflowRolesHistoryStub(channel) 7822 7823 def list(self, filter, *args, timeout=None): 7824 ''' 7825 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7826 ''' 7827 deadline = None if timeout is None else time.time() + timeout 7828 req = WorkflowRolesHistoryListRequest() 7829 req.meta.CopyFrom(ListRequestMetadata()) 7830 if self.parent.page_limit > 0: 7831 req.meta.limit = self.parent.page_limit 7832 if self.parent.snapshot_datetime is not None: 7833 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7834 7835 req.filter = plumbing.quote_filter_args(filter, *args) 7836 7837 def generator(svc, req): 7838 tries = 0 7839 while True: 7840 t = None if deadline is None else deadline - time.time() 7841 try: 7842 plumbing_response = svc.stub.List( 7843 req, 7844 metadata=svc.parent.get_metadata( 7845 'WorkflowRolesHistory.List', req), 7846 timeout=t) 7847 except Exception as e: 7848 if self.parent.shouldRetry(tries, e, deadline): 7849 tries += 1 7850 time.sleep( 7851 self.parent.exponentialBackoff(tries, deadline)) 7852 continue 7853 raise plumbing.convert_error_to_porcelain(e) from e 7854 tries = 0 7855 for plumbing_item in plumbing_response.history: 7856 yield plumbing.convert_workflow_role_history_to_porcelain( 7857 plumbing_item) 7858 if plumbing_response.meta.next_cursor == '': 7859 break 7860 req.meta.cursor = plumbing_response.meta.next_cursor 7861 7862 return generator(self, req) 7863 7864 7865class Workflows: 7866 ''' 7867 Workflows are the collection of rules that define the resources to which access can be requested, 7868 the users that can request that access, and the mechanism for approving those requests which can either 7869 be automatic approval or a set of users authorized to approve the requests. 7870 See `strongdm.models.Workflow`. 7871 ''' 7872 def __init__(self, channel, client): 7873 self.parent = client 7874 self.stub = WorkflowsStub(channel) 7875 7876 def create(self, workflow, timeout=None): 7877 ''' 7878 Create creates a new workflow and requires a name for the workflow. 7879 ''' 7880 deadline = None if timeout is None else time.time() + timeout 7881 req = WorkflowCreateRequest() 7882 7883 if workflow is not None: 7884 req.workflow.CopyFrom( 7885 plumbing.convert_workflow_to_plumbing(workflow)) 7886 tries = 0 7887 plumbing_response = None 7888 while True: 7889 t = None if deadline is None else deadline - time.time() 7890 try: 7891 plumbing_response = self.stub.Create( 7892 req, 7893 metadata=self.parent.get_metadata('Workflows.Create', req), 7894 timeout=t) 7895 except Exception as e: 7896 if self.parent.shouldRetry(tries, e, deadline): 7897 tries += 1 7898 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7899 continue 7900 raise plumbing.convert_error_to_porcelain(e) from e 7901 break 7902 7903 resp = models.WorkflowCreateResponse() 7904 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7905 plumbing_response.rate_limit) 7906 resp.workflow = plumbing.convert_workflow_to_porcelain( 7907 plumbing_response.workflow) 7908 return resp 7909 7910 def get(self, id, timeout=None): 7911 ''' 7912 Get reads one workflow by ID. 7913 ''' 7914 deadline = None if timeout is None else time.time() + timeout 7915 req = WorkflowGetRequest() 7916 if self.parent.snapshot_datetime is not None: 7917 req.meta.CopyFrom(GetRequestMetadata()) 7918 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7919 7920 req.id = (id) 7921 tries = 0 7922 plumbing_response = None 7923 while True: 7924 t = None if deadline is None else deadline - time.time() 7925 try: 7926 plumbing_response = self.stub.Get( 7927 req, 7928 metadata=self.parent.get_metadata('Workflows.Get', req), 7929 timeout=t) 7930 except Exception as e: 7931 if self.parent.shouldRetry(tries, e, deadline): 7932 tries += 1 7933 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7934 continue 7935 raise plumbing.convert_error_to_porcelain(e) from e 7936 break 7937 7938 resp = models.WorkflowGetResponse() 7939 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7940 plumbing_response.meta) 7941 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7942 plumbing_response.rate_limit) 7943 resp.workflow = plumbing.convert_workflow_to_porcelain( 7944 plumbing_response.workflow) 7945 return resp 7946 7947 def delete(self, id, timeout=None): 7948 ''' 7949 Delete deletes an existing workflow. 7950 ''' 7951 deadline = None if timeout is None else time.time() + timeout 7952 req = WorkflowDeleteRequest() 7953 7954 req.id = (id) 7955 tries = 0 7956 plumbing_response = None 7957 while True: 7958 t = None if deadline is None else deadline - time.time() 7959 try: 7960 plumbing_response = self.stub.Delete( 7961 req, 7962 metadata=self.parent.get_metadata('Workflows.Delete', req), 7963 timeout=t) 7964 except Exception as e: 7965 if self.parent.shouldRetry(tries, e, deadline): 7966 tries += 1 7967 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7968 continue 7969 raise plumbing.convert_error_to_porcelain(e) from e 7970 break 7971 7972 resp = models.WorkflowDeleteResponse() 7973 resp.id = (plumbing_response.id) 7974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7975 plumbing_response.rate_limit) 7976 return resp 7977 7978 def update(self, workflow, timeout=None): 7979 ''' 7980 Update updates an existing workflow. 7981 ''' 7982 deadline = None if timeout is None else time.time() + timeout 7983 req = WorkflowUpdateRequest() 7984 7985 if workflow is not None: 7986 req.workflow.CopyFrom( 7987 plumbing.convert_workflow_to_plumbing(workflow)) 7988 tries = 0 7989 plumbing_response = None 7990 while True: 7991 t = None if deadline is None else deadline - time.time() 7992 try: 7993 plumbing_response = self.stub.Update( 7994 req, 7995 metadata=self.parent.get_metadata('Workflows.Update', req), 7996 timeout=t) 7997 except Exception as e: 7998 if self.parent.shouldRetry(tries, e, deadline): 7999 tries += 1 8000 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8001 continue 8002 raise plumbing.convert_error_to_porcelain(e) from e 8003 break 8004 8005 resp = models.WorkflowUpdateResponse() 8006 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8007 plumbing_response.rate_limit) 8008 resp.workflow = plumbing.convert_workflow_to_porcelain( 8009 plumbing_response.workflow) 8010 return resp 8011 8012 def list(self, filter, *args, timeout=None): 8013 ''' 8014 Lists existing workflows. 8015 ''' 8016 deadline = None if timeout is None else time.time() + timeout 8017 req = WorkflowListRequest() 8018 req.meta.CopyFrom(ListRequestMetadata()) 8019 if self.parent.page_limit > 0: 8020 req.meta.limit = self.parent.page_limit 8021 if self.parent.snapshot_datetime is not None: 8022 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8023 8024 req.filter = plumbing.quote_filter_args(filter, *args) 8025 8026 def generator(svc, req): 8027 tries = 0 8028 while True: 8029 t = None if deadline is None else deadline - time.time() 8030 try: 8031 plumbing_response = svc.stub.List( 8032 req, 8033 metadata=svc.parent.get_metadata( 8034 'Workflows.List', req), 8035 timeout=t) 8036 except Exception as e: 8037 if self.parent.shouldRetry(tries, e, deadline): 8038 tries += 1 8039 time.sleep( 8040 self.parent.exponentialBackoff(tries, deadline)) 8041 continue 8042 raise plumbing.convert_error_to_porcelain(e) from e 8043 tries = 0 8044 for plumbing_item in plumbing_response.workflows: 8045 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8046 if plumbing_response.meta.next_cursor == '': 8047 break 8048 req.meta.cursor = plumbing_response.meta.next_cursor 8049 8050 return generator(self, req) 8051 8052 8053class SnapshotWorkflows: 8054 ''' 8055 SnapshotWorkflows exposes the read only methods of the Workflows 8056 service for historical queries. 8057 ''' 8058 def __init__(self, workflows): 8059 self.workflows = workflows 8060 8061 def get(self, id, timeout=None): 8062 ''' 8063 Get reads one workflow by ID. 8064 ''' 8065 return self.workflows.get(id, timeout=timeout) 8066 8067 def list(self, filter, *args, timeout=None): 8068 ''' 8069 Lists existing workflows. 8070 ''' 8071 return self.workflows.list(filter, *args, timeout=timeout) 8072 8073 8074class WorkflowsHistory: 8075 ''' 8076 WorkflowsHistory provides records of all changes to the state of a Workflow. 8077 See `strongdm.models.WorkflowHistory`. 8078 ''' 8079 def __init__(self, channel, client): 8080 self.parent = client 8081 self.stub = WorkflowsHistoryStub(channel) 8082 8083 def list(self, filter, *args, timeout=None): 8084 ''' 8085 List gets a list of WorkflowHistory records matching a given set of criteria. 8086 ''' 8087 deadline = None if timeout is None else time.time() + timeout 8088 req = WorkflowHistoryListRequest() 8089 req.meta.CopyFrom(ListRequestMetadata()) 8090 if self.parent.page_limit > 0: 8091 req.meta.limit = self.parent.page_limit 8092 if self.parent.snapshot_datetime is not None: 8093 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8094 8095 req.filter = plumbing.quote_filter_args(filter, *args) 8096 8097 def generator(svc, req): 8098 tries = 0 8099 while True: 8100 t = None if deadline is None else deadline - time.time() 8101 try: 8102 plumbing_response = svc.stub.List( 8103 req, 8104 metadata=svc.parent.get_metadata( 8105 'WorkflowsHistory.List', req), 8106 timeout=t) 8107 except Exception as e: 8108 if self.parent.shouldRetry(tries, e, deadline): 8109 tries += 1 8110 time.sleep( 8111 self.parent.exponentialBackoff(tries, deadline)) 8112 continue 8113 raise plumbing.convert_error_to_porcelain(e) from e 8114 tries = 0 8115 for plumbing_item in plumbing_response.history: 8116 yield plumbing.convert_workflow_history_to_porcelain( 8117 plumbing_item) 8118 if plumbing_response.meta.next_cursor == '': 8119 break 8120 req.meta.cursor = plumbing_response.meta.next_cursor 8121 8122 return generator(self, req)
def
deprecated(func)
169def deprecated(func): 170 """This is a decorator which can be used to mark functions 171 as deprecated. It will result in a warning being emitted 172 when the function is used.""" 173 @functools.wraps(func) 174 def new_func(*args, **kwargs): 175 warnings.warn("Call to deprecated function {}.".format(func.__name__), 176 category=DeprecationWarning, 177 stacklevel=2) 178 return func(*args, **kwargs) 179 180 return new_func
This is a decorator which can be used to mark functions as deprecated. It will result in a warning being emitted when the function is used.
class
AccessRequests:
183class AccessRequests: 184 ''' 185 AccessRequests are requests for access to a resource that may match a Workflow. 186 See `strongdm.models.AccessRequest`. 187 ''' 188 def __init__(self, channel, client): 189 self.parent = client 190 self.stub = AccessRequestsStub(channel) 191 192 def list(self, filter, *args, timeout=None): 193 ''' 194 Lists existing access requests. 195 ''' 196 deadline = None if timeout is None else time.time() + timeout 197 req = AccessRequestListRequest() 198 req.meta.CopyFrom(ListRequestMetadata()) 199 if self.parent.page_limit > 0: 200 req.meta.limit = self.parent.page_limit 201 if self.parent.snapshot_datetime is not None: 202 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 203 204 req.filter = plumbing.quote_filter_args(filter, *args) 205 206 def generator(svc, req): 207 tries = 0 208 while True: 209 t = None if deadline is None else deadline - time.time() 210 try: 211 plumbing_response = svc.stub.List( 212 req, 213 metadata=svc.parent.get_metadata( 214 'AccessRequests.List', req), 215 timeout=t) 216 except Exception as e: 217 if self.parent.shouldRetry(tries, e, deadline): 218 tries += 1 219 time.sleep( 220 self.parent.exponentialBackoff(tries, deadline)) 221 continue 222 raise plumbing.convert_error_to_porcelain(e) from e 223 tries = 0 224 for plumbing_item in plumbing_response.access_requests: 225 yield plumbing.convert_access_request_to_porcelain( 226 plumbing_item) 227 if plumbing_response.meta.next_cursor == '': 228 break 229 req.meta.cursor = plumbing_response.meta.next_cursor 230 231 return generator(self, req)
AccessRequests are requests for access to a resource that may match a Workflow.
See strongdm.models.AccessRequest.
def
list(self, filter, *args, timeout=None)
192 def list(self, filter, *args, timeout=None): 193 ''' 194 Lists existing access requests. 195 ''' 196 deadline = None if timeout is None else time.time() + timeout 197 req = AccessRequestListRequest() 198 req.meta.CopyFrom(ListRequestMetadata()) 199 if self.parent.page_limit > 0: 200 req.meta.limit = self.parent.page_limit 201 if self.parent.snapshot_datetime is not None: 202 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 203 204 req.filter = plumbing.quote_filter_args(filter, *args) 205 206 def generator(svc, req): 207 tries = 0 208 while True: 209 t = None if deadline is None else deadline - time.time() 210 try: 211 plumbing_response = svc.stub.List( 212 req, 213 metadata=svc.parent.get_metadata( 214 'AccessRequests.List', req), 215 timeout=t) 216 except Exception as e: 217 if self.parent.shouldRetry(tries, e, deadline): 218 tries += 1 219 time.sleep( 220 self.parent.exponentialBackoff(tries, deadline)) 221 continue 222 raise plumbing.convert_error_to_porcelain(e) from e 223 tries = 0 224 for plumbing_item in plumbing_response.access_requests: 225 yield plumbing.convert_access_request_to_porcelain( 226 plumbing_item) 227 if plumbing_response.meta.next_cursor == '': 228 break 229 req.meta.cursor = plumbing_response.meta.next_cursor 230 231 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
234class SnapshotAccessRequests: 235 ''' 236 SnapshotAccessRequests exposes the read only methods of the AccessRequests 237 service for historical queries. 238 ''' 239 def __init__(self, access_requests): 240 self.access_requests = access_requests 241 242 def list(self, filter, *args, timeout=None): 243 ''' 244 Lists existing access requests. 245 ''' 246 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
249class AccessRequestEventsHistory: 250 ''' 251 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 252 See `strongdm.models.AccessRequestEventHistory`. 253 ''' 254 def __init__(self, channel, client): 255 self.parent = client 256 self.stub = AccessRequestEventsHistoryStub(channel) 257 258 def list(self, filter, *args, timeout=None): 259 ''' 260 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 261 ''' 262 deadline = None if timeout is None else time.time() + timeout 263 req = AccessRequestEventHistoryListRequest() 264 req.meta.CopyFrom(ListRequestMetadata()) 265 if self.parent.page_limit > 0: 266 req.meta.limit = self.parent.page_limit 267 if self.parent.snapshot_datetime is not None: 268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 269 270 req.filter = plumbing.quote_filter_args(filter, *args) 271 272 def generator(svc, req): 273 tries = 0 274 while True: 275 t = None if deadline is None else deadline - time.time() 276 try: 277 plumbing_response = svc.stub.List( 278 req, 279 metadata=svc.parent.get_metadata( 280 'AccessRequestEventsHistory.List', req), 281 timeout=t) 282 except Exception as e: 283 if self.parent.shouldRetry(tries, e, deadline): 284 tries += 1 285 time.sleep( 286 self.parent.exponentialBackoff(tries, deadline)) 287 continue 288 raise plumbing.convert_error_to_porcelain(e) from e 289 tries = 0 290 for plumbing_item in plumbing_response.history: 291 yield plumbing.convert_access_request_event_history_to_porcelain( 292 plumbing_item) 293 if plumbing_response.meta.next_cursor == '': 294 break 295 req.meta.cursor = plumbing_response.meta.next_cursor 296 297 return generator(self, req)
AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest.
See strongdm.models.AccessRequestEventHistory.
def
list(self, filter, *args, timeout=None)
258 def list(self, filter, *args, timeout=None): 259 ''' 260 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 261 ''' 262 deadline = None if timeout is None else time.time() + timeout 263 req = AccessRequestEventHistoryListRequest() 264 req.meta.CopyFrom(ListRequestMetadata()) 265 if self.parent.page_limit > 0: 266 req.meta.limit = self.parent.page_limit 267 if self.parent.snapshot_datetime is not None: 268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 269 270 req.filter = plumbing.quote_filter_args(filter, *args) 271 272 def generator(svc, req): 273 tries = 0 274 while True: 275 t = None if deadline is None else deadline - time.time() 276 try: 277 plumbing_response = svc.stub.List( 278 req, 279 metadata=svc.parent.get_metadata( 280 'AccessRequestEventsHistory.List', req), 281 timeout=t) 282 except Exception as e: 283 if self.parent.shouldRetry(tries, e, deadline): 284 tries += 1 285 time.sleep( 286 self.parent.exponentialBackoff(tries, deadline)) 287 continue 288 raise plumbing.convert_error_to_porcelain(e) from e 289 tries = 0 290 for plumbing_item in plumbing_response.history: 291 yield plumbing.convert_access_request_event_history_to_porcelain( 292 plumbing_item) 293 if plumbing_response.meta.next_cursor == '': 294 break 295 req.meta.cursor = plumbing_response.meta.next_cursor 296 297 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
300class AccessRequestsHistory: 301 ''' 302 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 303 See `strongdm.models.AccessRequestHistory`. 304 ''' 305 def __init__(self, channel, client): 306 self.parent = client 307 self.stub = AccessRequestsHistoryStub(channel) 308 309 def list(self, filter, *args, timeout=None): 310 ''' 311 List gets a list of AccessRequestHistory records matching a given set of criteria. 312 ''' 313 deadline = None if timeout is None else time.time() + timeout 314 req = AccessRequestHistoryListRequest() 315 req.meta.CopyFrom(ListRequestMetadata()) 316 if self.parent.page_limit > 0: 317 req.meta.limit = self.parent.page_limit 318 if self.parent.snapshot_datetime is not None: 319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 320 321 req.filter = plumbing.quote_filter_args(filter, *args) 322 323 def generator(svc, req): 324 tries = 0 325 while True: 326 t = None if deadline is None else deadline - time.time() 327 try: 328 plumbing_response = svc.stub.List( 329 req, 330 metadata=svc.parent.get_metadata( 331 'AccessRequestsHistory.List', req), 332 timeout=t) 333 except Exception as e: 334 if self.parent.shouldRetry(tries, e, deadline): 335 tries += 1 336 time.sleep( 337 self.parent.exponentialBackoff(tries, deadline)) 338 continue 339 raise plumbing.convert_error_to_porcelain(e) from e 340 tries = 0 341 for plumbing_item in plumbing_response.history: 342 yield plumbing.convert_access_request_history_to_porcelain( 343 plumbing_item) 344 if plumbing_response.meta.next_cursor == '': 345 break 346 req.meta.cursor = plumbing_response.meta.next_cursor 347 348 return generator(self, req)
AccessRequestsHistory provides records of all changes to the state of an AccessRequest.
See strongdm.models.AccessRequestHistory.
def
list(self, filter, *args, timeout=None)
309 def list(self, filter, *args, timeout=None): 310 ''' 311 List gets a list of AccessRequestHistory records matching a given set of criteria. 312 ''' 313 deadline = None if timeout is None else time.time() + timeout 314 req = AccessRequestHistoryListRequest() 315 req.meta.CopyFrom(ListRequestMetadata()) 316 if self.parent.page_limit > 0: 317 req.meta.limit = self.parent.page_limit 318 if self.parent.snapshot_datetime is not None: 319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 320 321 req.filter = plumbing.quote_filter_args(filter, *args) 322 323 def generator(svc, req): 324 tries = 0 325 while True: 326 t = None if deadline is None else deadline - time.time() 327 try: 328 plumbing_response = svc.stub.List( 329 req, 330 metadata=svc.parent.get_metadata( 331 'AccessRequestsHistory.List', req), 332 timeout=t) 333 except Exception as e: 334 if self.parent.shouldRetry(tries, e, deadline): 335 tries += 1 336 time.sleep( 337 self.parent.exponentialBackoff(tries, deadline)) 338 continue 339 raise plumbing.convert_error_to_porcelain(e) from e 340 tries = 0 341 for plumbing_item in plumbing_response.history: 342 yield plumbing.convert_access_request_history_to_porcelain( 343 plumbing_item) 344 if plumbing_response.meta.next_cursor == '': 345 break 346 req.meta.cursor = plumbing_response.meta.next_cursor 347 348 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
351class AccountAttachments: 352 ''' 353 AccountAttachments assign an account to a role. 354 See `strongdm.models.AccountAttachment`. 355 ''' 356 def __init__(self, channel, client): 357 self.parent = client 358 self.stub = AccountAttachmentsStub(channel) 359 360 def create(self, account_attachment, timeout=None): 361 ''' 362 Create registers a new AccountAttachment. 363 ''' 364 deadline = None if timeout is None else time.time() + timeout 365 req = AccountAttachmentCreateRequest() 366 367 if account_attachment is not None: 368 req.account_attachment.CopyFrom( 369 plumbing.convert_account_attachment_to_plumbing( 370 account_attachment)) 371 tries = 0 372 plumbing_response = None 373 while True: 374 t = None if deadline is None else deadline - time.time() 375 try: 376 plumbing_response = self.stub.Create( 377 req, 378 metadata=self.parent.get_metadata( 379 'AccountAttachments.Create', req), 380 timeout=t) 381 except Exception as e: 382 if self.parent.shouldRetry(tries, e, deadline): 383 tries += 1 384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 385 continue 386 raise plumbing.convert_error_to_porcelain(e) from e 387 break 388 389 resp = models.AccountAttachmentCreateResponse() 390 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 391 plumbing_response.account_attachment) 392 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 393 plumbing_response.meta) 394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 395 plumbing_response.rate_limit) 396 return resp 397 398 def get(self, id, timeout=None): 399 ''' 400 Get reads one AccountAttachment by ID. 401 ''' 402 deadline = None if timeout is None else time.time() + timeout 403 req = AccountAttachmentGetRequest() 404 if self.parent.snapshot_datetime is not None: 405 req.meta.CopyFrom(GetRequestMetadata()) 406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 407 408 req.id = (id) 409 tries = 0 410 plumbing_response = None 411 while True: 412 t = None if deadline is None else deadline - time.time() 413 try: 414 plumbing_response = self.stub.Get( 415 req, 416 metadata=self.parent.get_metadata('AccountAttachments.Get', 417 req), 418 timeout=t) 419 except Exception as e: 420 if self.parent.shouldRetry(tries, e, deadline): 421 tries += 1 422 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 423 continue 424 raise plumbing.convert_error_to_porcelain(e) from e 425 break 426 427 resp = models.AccountAttachmentGetResponse() 428 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 429 plumbing_response.account_attachment) 430 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 431 plumbing_response.meta) 432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 433 plumbing_response.rate_limit) 434 return resp 435 436 def delete(self, id, timeout=None): 437 ''' 438 Delete removes a AccountAttachment by ID. 439 ''' 440 deadline = None if timeout is None else time.time() + timeout 441 req = AccountAttachmentDeleteRequest() 442 443 req.id = (id) 444 tries = 0 445 plumbing_response = None 446 while True: 447 t = None if deadline is None else deadline - time.time() 448 try: 449 plumbing_response = self.stub.Delete( 450 req, 451 metadata=self.parent.get_metadata( 452 'AccountAttachments.Delete', req), 453 timeout=t) 454 except Exception as e: 455 if self.parent.shouldRetry(tries, e, deadline): 456 tries += 1 457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 458 continue 459 raise plumbing.convert_error_to_porcelain(e) from e 460 break 461 462 resp = models.AccountAttachmentDeleteResponse() 463 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 464 plumbing_response.meta) 465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 466 plumbing_response.rate_limit) 467 return resp 468 469 def list(self, filter, *args, timeout=None): 470 ''' 471 List gets a list of AccountAttachments matching a given set of criteria. 472 ''' 473 deadline = None if timeout is None else time.time() + timeout 474 req = AccountAttachmentListRequest() 475 req.meta.CopyFrom(ListRequestMetadata()) 476 if self.parent.page_limit > 0: 477 req.meta.limit = self.parent.page_limit 478 if self.parent.snapshot_datetime is not None: 479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 480 481 req.filter = plumbing.quote_filter_args(filter, *args) 482 483 def generator(svc, req): 484 tries = 0 485 while True: 486 t = None if deadline is None else deadline - time.time() 487 try: 488 plumbing_response = svc.stub.List( 489 req, 490 metadata=svc.parent.get_metadata( 491 'AccountAttachments.List', req), 492 timeout=t) 493 except Exception as e: 494 if self.parent.shouldRetry(tries, e, deadline): 495 tries += 1 496 time.sleep( 497 self.parent.exponentialBackoff(tries, deadline)) 498 continue 499 raise plumbing.convert_error_to_porcelain(e) from e 500 tries = 0 501 for plumbing_item in plumbing_response.account_attachments: 502 yield plumbing.convert_account_attachment_to_porcelain( 503 plumbing_item) 504 if plumbing_response.meta.next_cursor == '': 505 break 506 req.meta.cursor = plumbing_response.meta.next_cursor 507 508 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
360 def create(self, account_attachment, timeout=None): 361 ''' 362 Create registers a new AccountAttachment. 363 ''' 364 deadline = None if timeout is None else time.time() + timeout 365 req = AccountAttachmentCreateRequest() 366 367 if account_attachment is not None: 368 req.account_attachment.CopyFrom( 369 plumbing.convert_account_attachment_to_plumbing( 370 account_attachment)) 371 tries = 0 372 plumbing_response = None 373 while True: 374 t = None if deadline is None else deadline - time.time() 375 try: 376 plumbing_response = self.stub.Create( 377 req, 378 metadata=self.parent.get_metadata( 379 'AccountAttachments.Create', req), 380 timeout=t) 381 except Exception as e: 382 if self.parent.shouldRetry(tries, e, deadline): 383 tries += 1 384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 385 continue 386 raise plumbing.convert_error_to_porcelain(e) from e 387 break 388 389 resp = models.AccountAttachmentCreateResponse() 390 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 391 plumbing_response.account_attachment) 392 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 393 plumbing_response.meta) 394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 395 plumbing_response.rate_limit) 396 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
398 def get(self, id, timeout=None): 399 ''' 400 Get reads one AccountAttachment by ID. 401 ''' 402 deadline = None if timeout is None else time.time() + timeout 403 req = AccountAttachmentGetRequest() 404 if self.parent.snapshot_datetime is not None: 405 req.meta.CopyFrom(GetRequestMetadata()) 406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 407 408 req.id = (id) 409 tries = 0 410 plumbing_response = None 411 while True: 412 t = None if deadline is None else deadline - time.time() 413 try: 414 plumbing_response = self.stub.Get( 415 req, 416 metadata=self.parent.get_metadata('AccountAttachments.Get', 417 req), 418 timeout=t) 419 except Exception as e: 420 if self.parent.shouldRetry(tries, e, deadline): 421 tries += 1 422 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 423 continue 424 raise plumbing.convert_error_to_porcelain(e) from e 425 break 426 427 resp = models.AccountAttachmentGetResponse() 428 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 429 plumbing_response.account_attachment) 430 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 431 plumbing_response.meta) 432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 433 plumbing_response.rate_limit) 434 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
436 def delete(self, id, timeout=None): 437 ''' 438 Delete removes a AccountAttachment by ID. 439 ''' 440 deadline = None if timeout is None else time.time() + timeout 441 req = AccountAttachmentDeleteRequest() 442 443 req.id = (id) 444 tries = 0 445 plumbing_response = None 446 while True: 447 t = None if deadline is None else deadline - time.time() 448 try: 449 plumbing_response = self.stub.Delete( 450 req, 451 metadata=self.parent.get_metadata( 452 'AccountAttachments.Delete', req), 453 timeout=t) 454 except Exception as e: 455 if self.parent.shouldRetry(tries, e, deadline): 456 tries += 1 457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 458 continue 459 raise plumbing.convert_error_to_porcelain(e) from e 460 break 461 462 resp = models.AccountAttachmentDeleteResponse() 463 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 464 plumbing_response.meta) 465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 466 plumbing_response.rate_limit) 467 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
469 def list(self, filter, *args, timeout=None): 470 ''' 471 List gets a list of AccountAttachments matching a given set of criteria. 472 ''' 473 deadline = None if timeout is None else time.time() + timeout 474 req = AccountAttachmentListRequest() 475 req.meta.CopyFrom(ListRequestMetadata()) 476 if self.parent.page_limit > 0: 477 req.meta.limit = self.parent.page_limit 478 if self.parent.snapshot_datetime is not None: 479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 480 481 req.filter = plumbing.quote_filter_args(filter, *args) 482 483 def generator(svc, req): 484 tries = 0 485 while True: 486 t = None if deadline is None else deadline - time.time() 487 try: 488 plumbing_response = svc.stub.List( 489 req, 490 metadata=svc.parent.get_metadata( 491 'AccountAttachments.List', req), 492 timeout=t) 493 except Exception as e: 494 if self.parent.shouldRetry(tries, e, deadline): 495 tries += 1 496 time.sleep( 497 self.parent.exponentialBackoff(tries, deadline)) 498 continue 499 raise plumbing.convert_error_to_porcelain(e) from e 500 tries = 0 501 for plumbing_item in plumbing_response.account_attachments: 502 yield plumbing.convert_account_attachment_to_porcelain( 503 plumbing_item) 504 if plumbing_response.meta.next_cursor == '': 505 break 506 req.meta.cursor = plumbing_response.meta.next_cursor 507 508 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
511class SnapshotAccountAttachments: 512 ''' 513 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 514 service for historical queries. 515 ''' 516 def __init__(self, account_attachments): 517 self.account_attachments = account_attachments 518 519 def get(self, id, timeout=None): 520 ''' 521 Get reads one AccountAttachment by ID. 522 ''' 523 return self.account_attachments.get(id, timeout=timeout) 524 525 def list(self, filter, *args, timeout=None): 526 ''' 527 List gets a list of AccountAttachments matching a given set of criteria. 528 ''' 529 return self.account_attachments.list(filter, *args, timeout=timeout)
SnapshotAccountAttachments exposes the read only methods of the AccountAttachments service for historical queries.
def
get(self, id, timeout=None)
519 def get(self, id, timeout=None): 520 ''' 521 Get reads one AccountAttachment by ID. 522 ''' 523 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
525 def list(self, filter, *args, timeout=None): 526 ''' 527 List gets a list of AccountAttachments matching a given set of criteria. 528 ''' 529 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
532class AccountAttachmentsHistory: 533 ''' 534 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 535 See `strongdm.models.AccountAttachmentHistory`. 536 ''' 537 def __init__(self, channel, client): 538 self.parent = client 539 self.stub = AccountAttachmentsHistoryStub(channel) 540 541 def list(self, filter, *args, timeout=None): 542 ''' 543 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 544 ''' 545 deadline = None if timeout is None else time.time() + timeout 546 req = AccountAttachmentHistoryListRequest() 547 req.meta.CopyFrom(ListRequestMetadata()) 548 if self.parent.page_limit > 0: 549 req.meta.limit = self.parent.page_limit 550 if self.parent.snapshot_datetime is not None: 551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 552 553 req.filter = plumbing.quote_filter_args(filter, *args) 554 555 def generator(svc, req): 556 tries = 0 557 while True: 558 t = None if deadline is None else deadline - time.time() 559 try: 560 plumbing_response = svc.stub.List( 561 req, 562 metadata=svc.parent.get_metadata( 563 'AccountAttachmentsHistory.List', req), 564 timeout=t) 565 except Exception as e: 566 if self.parent.shouldRetry(tries, e, deadline): 567 tries += 1 568 time.sleep( 569 self.parent.exponentialBackoff(tries, deadline)) 570 continue 571 raise plumbing.convert_error_to_porcelain(e) from e 572 tries = 0 573 for plumbing_item in plumbing_response.history: 574 yield plumbing.convert_account_attachment_history_to_porcelain( 575 plumbing_item) 576 if plumbing_response.meta.next_cursor == '': 577 break 578 req.meta.cursor = plumbing_response.meta.next_cursor 579 580 return generator(self, req)
AccountAttachmentsHistory records all changes to the state of an AccountAttachment.
See strongdm.models.AccountAttachmentHistory.
def
list(self, filter, *args, timeout=None)
541 def list(self, filter, *args, timeout=None): 542 ''' 543 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 544 ''' 545 deadline = None if timeout is None else time.time() + timeout 546 req = AccountAttachmentHistoryListRequest() 547 req.meta.CopyFrom(ListRequestMetadata()) 548 if self.parent.page_limit > 0: 549 req.meta.limit = self.parent.page_limit 550 if self.parent.snapshot_datetime is not None: 551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 552 553 req.filter = plumbing.quote_filter_args(filter, *args) 554 555 def generator(svc, req): 556 tries = 0 557 while True: 558 t = None if deadline is None else deadline - time.time() 559 try: 560 plumbing_response = svc.stub.List( 561 req, 562 metadata=svc.parent.get_metadata( 563 'AccountAttachmentsHistory.List', req), 564 timeout=t) 565 except Exception as e: 566 if self.parent.shouldRetry(tries, e, deadline): 567 tries += 1 568 time.sleep( 569 self.parent.exponentialBackoff(tries, deadline)) 570 continue 571 raise plumbing.convert_error_to_porcelain(e) from e 572 tries = 0 573 for plumbing_item in plumbing_response.history: 574 yield plumbing.convert_account_attachment_history_to_porcelain( 575 plumbing_item) 576 if plumbing_response.meta.next_cursor == '': 577 break 578 req.meta.cursor = plumbing_response.meta.next_cursor 579 580 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
583class AccountGrants: 584 ''' 585 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 586 See `strongdm.models.AccountGrant`. 587 ''' 588 def __init__(self, channel, client): 589 self.parent = client 590 self.stub = AccountGrantsStub(channel) 591 592 def create(self, account_grant, timeout=None): 593 ''' 594 Create registers a new AccountGrant. 595 ''' 596 deadline = None if timeout is None else time.time() + timeout 597 req = AccountGrantCreateRequest() 598 599 if account_grant is not None: 600 req.account_grant.CopyFrom( 601 plumbing.convert_account_grant_to_plumbing(account_grant)) 602 tries = 0 603 plumbing_response = None 604 while True: 605 t = None if deadline is None else deadline - time.time() 606 try: 607 plumbing_response = self.stub.Create( 608 req, 609 metadata=self.parent.get_metadata('AccountGrants.Create', 610 req), 611 timeout=t) 612 except Exception as e: 613 if self.parent.shouldRetry(tries, e, deadline): 614 tries += 1 615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 616 continue 617 raise plumbing.convert_error_to_porcelain(e) from e 618 break 619 620 resp = models.AccountGrantCreateResponse() 621 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 622 plumbing_response.account_grant) 623 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 624 plumbing_response.meta) 625 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 626 plumbing_response.rate_limit) 627 return resp 628 629 def get(self, id, timeout=None): 630 ''' 631 Get reads one AccountGrant by ID. 632 ''' 633 deadline = None if timeout is None else time.time() + timeout 634 req = AccountGrantGetRequest() 635 if self.parent.snapshot_datetime is not None: 636 req.meta.CopyFrom(GetRequestMetadata()) 637 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 638 639 req.id = (id) 640 tries = 0 641 plumbing_response = None 642 while True: 643 t = None if deadline is None else deadline - time.time() 644 try: 645 plumbing_response = self.stub.Get( 646 req, 647 metadata=self.parent.get_metadata('AccountGrants.Get', 648 req), 649 timeout=t) 650 except Exception as e: 651 if self.parent.shouldRetry(tries, e, deadline): 652 tries += 1 653 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 654 continue 655 raise plumbing.convert_error_to_porcelain(e) from e 656 break 657 658 resp = models.AccountGrantGetResponse() 659 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 660 plumbing_response.account_grant) 661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 662 plumbing_response.meta) 663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 664 plumbing_response.rate_limit) 665 return resp 666 667 def delete(self, id, timeout=None): 668 ''' 669 Delete removes a AccountGrant by ID. 670 ''' 671 deadline = None if timeout is None else time.time() + timeout 672 req = AccountGrantDeleteRequest() 673 674 req.id = (id) 675 tries = 0 676 plumbing_response = None 677 while True: 678 t = None if deadline is None else deadline - time.time() 679 try: 680 plumbing_response = self.stub.Delete( 681 req, 682 metadata=self.parent.get_metadata('AccountGrants.Delete', 683 req), 684 timeout=t) 685 except Exception as e: 686 if self.parent.shouldRetry(tries, e, deadline): 687 tries += 1 688 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 689 continue 690 raise plumbing.convert_error_to_porcelain(e) from e 691 break 692 693 resp = models.AccountGrantDeleteResponse() 694 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 695 plumbing_response.meta) 696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 697 plumbing_response.rate_limit) 698 return resp 699 700 def list(self, filter, *args, timeout=None): 701 ''' 702 List gets a list of AccountGrants matching a given set of criteria. 703 ''' 704 deadline = None if timeout is None else time.time() + timeout 705 req = AccountGrantListRequest() 706 req.meta.CopyFrom(ListRequestMetadata()) 707 if self.parent.page_limit > 0: 708 req.meta.limit = self.parent.page_limit 709 if self.parent.snapshot_datetime is not None: 710 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 711 712 req.filter = plumbing.quote_filter_args(filter, *args) 713 714 def generator(svc, req): 715 tries = 0 716 while True: 717 t = None if deadline is None else deadline - time.time() 718 try: 719 plumbing_response = svc.stub.List( 720 req, 721 metadata=svc.parent.get_metadata( 722 'AccountGrants.List', req), 723 timeout=t) 724 except Exception as e: 725 if self.parent.shouldRetry(tries, e, deadline): 726 tries += 1 727 time.sleep( 728 self.parent.exponentialBackoff(tries, deadline)) 729 continue 730 raise plumbing.convert_error_to_porcelain(e) from e 731 tries = 0 732 for plumbing_item in plumbing_response.account_grants: 733 yield plumbing.convert_account_grant_to_porcelain( 734 plumbing_item) 735 if plumbing_response.meta.next_cursor == '': 736 break 737 req.meta.cursor = plumbing_response.meta.next_cursor 738 739 return generator(self, req)
AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource.
See strongdm.models.AccountGrant.
def
create(self, account_grant, timeout=None)
592 def create(self, account_grant, timeout=None): 593 ''' 594 Create registers a new AccountGrant. 595 ''' 596 deadline = None if timeout is None else time.time() + timeout 597 req = AccountGrantCreateRequest() 598 599 if account_grant is not None: 600 req.account_grant.CopyFrom( 601 plumbing.convert_account_grant_to_plumbing(account_grant)) 602 tries = 0 603 plumbing_response = None 604 while True: 605 t = None if deadline is None else deadline - time.time() 606 try: 607 plumbing_response = self.stub.Create( 608 req, 609 metadata=self.parent.get_metadata('AccountGrants.Create', 610 req), 611 timeout=t) 612 except Exception as e: 613 if self.parent.shouldRetry(tries, e, deadline): 614 tries += 1 615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 616 continue 617 raise plumbing.convert_error_to_porcelain(e) from e 618 break 619 620 resp = models.AccountGrantCreateResponse() 621 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 622 plumbing_response.account_grant) 623 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 624 plumbing_response.meta) 625 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 626 plumbing_response.rate_limit) 627 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
629 def get(self, id, timeout=None): 630 ''' 631 Get reads one AccountGrant by ID. 632 ''' 633 deadline = None if timeout is None else time.time() + timeout 634 req = AccountGrantGetRequest() 635 if self.parent.snapshot_datetime is not None: 636 req.meta.CopyFrom(GetRequestMetadata()) 637 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 638 639 req.id = (id) 640 tries = 0 641 plumbing_response = None 642 while True: 643 t = None if deadline is None else deadline - time.time() 644 try: 645 plumbing_response = self.stub.Get( 646 req, 647 metadata=self.parent.get_metadata('AccountGrants.Get', 648 req), 649 timeout=t) 650 except Exception as e: 651 if self.parent.shouldRetry(tries, e, deadline): 652 tries += 1 653 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 654 continue 655 raise plumbing.convert_error_to_porcelain(e) from e 656 break 657 658 resp = models.AccountGrantGetResponse() 659 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 660 plumbing_response.account_grant) 661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 662 plumbing_response.meta) 663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 664 plumbing_response.rate_limit) 665 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
667 def delete(self, id, timeout=None): 668 ''' 669 Delete removes a AccountGrant by ID. 670 ''' 671 deadline = None if timeout is None else time.time() + timeout 672 req = AccountGrantDeleteRequest() 673 674 req.id = (id) 675 tries = 0 676 plumbing_response = None 677 while True: 678 t = None if deadline is None else deadline - time.time() 679 try: 680 plumbing_response = self.stub.Delete( 681 req, 682 metadata=self.parent.get_metadata('AccountGrants.Delete', 683 req), 684 timeout=t) 685 except Exception as e: 686 if self.parent.shouldRetry(tries, e, deadline): 687 tries += 1 688 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 689 continue 690 raise plumbing.convert_error_to_porcelain(e) from e 691 break 692 693 resp = models.AccountGrantDeleteResponse() 694 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 695 plumbing_response.meta) 696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 697 plumbing_response.rate_limit) 698 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
700 def list(self, filter, *args, timeout=None): 701 ''' 702 List gets a list of AccountGrants matching a given set of criteria. 703 ''' 704 deadline = None if timeout is None else time.time() + timeout 705 req = AccountGrantListRequest() 706 req.meta.CopyFrom(ListRequestMetadata()) 707 if self.parent.page_limit > 0: 708 req.meta.limit = self.parent.page_limit 709 if self.parent.snapshot_datetime is not None: 710 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 711 712 req.filter = plumbing.quote_filter_args(filter, *args) 713 714 def generator(svc, req): 715 tries = 0 716 while True: 717 t = None if deadline is None else deadline - time.time() 718 try: 719 plumbing_response = svc.stub.List( 720 req, 721 metadata=svc.parent.get_metadata( 722 'AccountGrants.List', req), 723 timeout=t) 724 except Exception as e: 725 if self.parent.shouldRetry(tries, e, deadline): 726 tries += 1 727 time.sleep( 728 self.parent.exponentialBackoff(tries, deadline)) 729 continue 730 raise plumbing.convert_error_to_porcelain(e) from e 731 tries = 0 732 for plumbing_item in plumbing_response.account_grants: 733 yield plumbing.convert_account_grant_to_porcelain( 734 plumbing_item) 735 if plumbing_response.meta.next_cursor == '': 736 break 737 req.meta.cursor = plumbing_response.meta.next_cursor 738 739 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
742class SnapshotAccountGrants: 743 ''' 744 SnapshotAccountGrants exposes the read only methods of the AccountGrants 745 service for historical queries. 746 ''' 747 def __init__(self, account_grants): 748 self.account_grants = account_grants 749 750 def get(self, id, timeout=None): 751 ''' 752 Get reads one AccountGrant by ID. 753 ''' 754 return self.account_grants.get(id, timeout=timeout) 755 756 def list(self, filter, *args, timeout=None): 757 ''' 758 List gets a list of AccountGrants matching a given set of criteria. 759 ''' 760 return self.account_grants.list(filter, *args, timeout=timeout)
SnapshotAccountGrants exposes the read only methods of the AccountGrants service for historical queries.
def
get(self, id, timeout=None)
750 def get(self, id, timeout=None): 751 ''' 752 Get reads one AccountGrant by ID. 753 ''' 754 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
756 def list(self, filter, *args, timeout=None): 757 ''' 758 List gets a list of AccountGrants matching a given set of criteria. 759 ''' 760 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
763class AccountGrantsHistory: 764 ''' 765 AccountGrantsHistory records all changes to the state of an AccountGrant. 766 See `strongdm.models.AccountGrantHistory`. 767 ''' 768 def __init__(self, channel, client): 769 self.parent = client 770 self.stub = AccountGrantsHistoryStub(channel) 771 772 def list(self, filter, *args, timeout=None): 773 ''' 774 List gets a list of AccountGrantHistory records matching a given set of criteria. 775 ''' 776 deadline = None if timeout is None else time.time() + timeout 777 req = AccountGrantHistoryListRequest() 778 req.meta.CopyFrom(ListRequestMetadata()) 779 if self.parent.page_limit > 0: 780 req.meta.limit = self.parent.page_limit 781 if self.parent.snapshot_datetime is not None: 782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 783 784 req.filter = plumbing.quote_filter_args(filter, *args) 785 786 def generator(svc, req): 787 tries = 0 788 while True: 789 t = None if deadline is None else deadline - time.time() 790 try: 791 plumbing_response = svc.stub.List( 792 req, 793 metadata=svc.parent.get_metadata( 794 'AccountGrantsHistory.List', req), 795 timeout=t) 796 except Exception as e: 797 if self.parent.shouldRetry(tries, e, deadline): 798 tries += 1 799 time.sleep( 800 self.parent.exponentialBackoff(tries, deadline)) 801 continue 802 raise plumbing.convert_error_to_porcelain(e) from e 803 tries = 0 804 for plumbing_item in plumbing_response.history: 805 yield plumbing.convert_account_grant_history_to_porcelain( 806 plumbing_item) 807 if plumbing_response.meta.next_cursor == '': 808 break 809 req.meta.cursor = plumbing_response.meta.next_cursor 810 811 return generator(self, req)
AccountGrantsHistory records all changes to the state of an AccountGrant.
See strongdm.models.AccountGrantHistory.
def
list(self, filter, *args, timeout=None)
772 def list(self, filter, *args, timeout=None): 773 ''' 774 List gets a list of AccountGrantHistory records matching a given set of criteria. 775 ''' 776 deadline = None if timeout is None else time.time() + timeout 777 req = AccountGrantHistoryListRequest() 778 req.meta.CopyFrom(ListRequestMetadata()) 779 if self.parent.page_limit > 0: 780 req.meta.limit = self.parent.page_limit 781 if self.parent.snapshot_datetime is not None: 782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 783 784 req.filter = plumbing.quote_filter_args(filter, *args) 785 786 def generator(svc, req): 787 tries = 0 788 while True: 789 t = None if deadline is None else deadline - time.time() 790 try: 791 plumbing_response = svc.stub.List( 792 req, 793 metadata=svc.parent.get_metadata( 794 'AccountGrantsHistory.List', req), 795 timeout=t) 796 except Exception as e: 797 if self.parent.shouldRetry(tries, e, deadline): 798 tries += 1 799 time.sleep( 800 self.parent.exponentialBackoff(tries, deadline)) 801 continue 802 raise plumbing.convert_error_to_porcelain(e) from e 803 tries = 0 804 for plumbing_item in plumbing_response.history: 805 yield plumbing.convert_account_grant_history_to_porcelain( 806 plumbing_item) 807 if plumbing_response.meta.next_cursor == '': 808 break 809 req.meta.cursor = plumbing_response.meta.next_cursor 810 811 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
814class AccountPermissions: 815 ''' 816 AccountPermissions records the granular permissions accounts have, allowing them to execute 817 relevant commands via StrongDM's APIs. 818 See `strongdm.models.AccountPermission`. 819 ''' 820 def __init__(self, channel, client): 821 self.parent = client 822 self.stub = AccountPermissionsStub(channel) 823 824 def list(self, filter, *args, timeout=None): 825 ''' 826 List gets a list of Permission records matching a given set of criteria. 827 ''' 828 deadline = None if timeout is None else time.time() + timeout 829 req = AccountPermissionListRequest() 830 req.meta.CopyFrom(ListRequestMetadata()) 831 if self.parent.page_limit > 0: 832 req.meta.limit = self.parent.page_limit 833 if self.parent.snapshot_datetime is not None: 834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 835 836 req.filter = plumbing.quote_filter_args(filter, *args) 837 838 def generator(svc, req): 839 tries = 0 840 while True: 841 t = None if deadline is None else deadline - time.time() 842 try: 843 plumbing_response = svc.stub.List( 844 req, 845 metadata=svc.parent.get_metadata( 846 'AccountPermissions.List', req), 847 timeout=t) 848 except Exception as e: 849 if self.parent.shouldRetry(tries, e, deadline): 850 tries += 1 851 time.sleep( 852 self.parent.exponentialBackoff(tries, deadline)) 853 continue 854 raise plumbing.convert_error_to_porcelain(e) from e 855 tries = 0 856 for plumbing_item in plumbing_response.permissions: 857 yield plumbing.convert_account_permission_to_porcelain( 858 plumbing_item) 859 if plumbing_response.meta.next_cursor == '': 860 break 861 req.meta.cursor = plumbing_response.meta.next_cursor 862 863 return generator(self, req)
AccountPermissions records the granular permissions accounts have, allowing them to execute
relevant commands via StrongDM's APIs.
See strongdm.models.AccountPermission.
def
list(self, filter, *args, timeout=None)
824 def list(self, filter, *args, timeout=None): 825 ''' 826 List gets a list of Permission records matching a given set of criteria. 827 ''' 828 deadline = None if timeout is None else time.time() + timeout 829 req = AccountPermissionListRequest() 830 req.meta.CopyFrom(ListRequestMetadata()) 831 if self.parent.page_limit > 0: 832 req.meta.limit = self.parent.page_limit 833 if self.parent.snapshot_datetime is not None: 834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 835 836 req.filter = plumbing.quote_filter_args(filter, *args) 837 838 def generator(svc, req): 839 tries = 0 840 while True: 841 t = None if deadline is None else deadline - time.time() 842 try: 843 plumbing_response = svc.stub.List( 844 req, 845 metadata=svc.parent.get_metadata( 846 'AccountPermissions.List', req), 847 timeout=t) 848 except Exception as e: 849 if self.parent.shouldRetry(tries, e, deadline): 850 tries += 1 851 time.sleep( 852 self.parent.exponentialBackoff(tries, deadline)) 853 continue 854 raise plumbing.convert_error_to_porcelain(e) from e 855 tries = 0 856 for plumbing_item in plumbing_response.permissions: 857 yield plumbing.convert_account_permission_to_porcelain( 858 plumbing_item) 859 if plumbing_response.meta.next_cursor == '': 860 break 861 req.meta.cursor = plumbing_response.meta.next_cursor 862 863 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
866class SnapshotAccountPermissions: 867 ''' 868 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 869 service for historical queries. 870 ''' 871 def __init__(self, account_permissions): 872 self.account_permissions = account_permissions 873 874 def list(self, filter, *args, timeout=None): 875 ''' 876 List gets a list of Permission records matching a given set of criteria. 877 ''' 878 return self.account_permissions.list(filter, *args, timeout=timeout)
SnapshotAccountPermissions exposes the read only methods of the AccountPermissions service for historical queries.
def
list(self, filter, *args, timeout=None)
874 def list(self, filter, *args, timeout=None): 875 ''' 876 List gets a list of Permission records matching a given set of criteria. 877 ''' 878 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
881class AccountResources: 882 ''' 883 AccountResources enumerates the resources to which accounts have access. 884 The AccountResources service is read-only. 885 See `strongdm.models.AccountResource`. 886 ''' 887 def __init__(self, channel, client): 888 self.parent = client 889 self.stub = AccountResourcesStub(channel) 890 891 def list(self, filter, *args, timeout=None): 892 ''' 893 List gets a list of AccountResource records matching a given set of criteria. 894 ''' 895 deadline = None if timeout is None else time.time() + timeout 896 req = AccountResourceListRequest() 897 req.meta.CopyFrom(ListRequestMetadata()) 898 if self.parent.page_limit > 0: 899 req.meta.limit = self.parent.page_limit 900 if self.parent.snapshot_datetime is not None: 901 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 902 903 req.filter = plumbing.quote_filter_args(filter, *args) 904 905 def generator(svc, req): 906 tries = 0 907 while True: 908 t = None if deadline is None else deadline - time.time() 909 try: 910 plumbing_response = svc.stub.List( 911 req, 912 metadata=svc.parent.get_metadata( 913 'AccountResources.List', req), 914 timeout=t) 915 except Exception as e: 916 if self.parent.shouldRetry(tries, e, deadline): 917 tries += 1 918 time.sleep( 919 self.parent.exponentialBackoff(tries, deadline)) 920 continue 921 raise plumbing.convert_error_to_porcelain(e) from e 922 tries = 0 923 for plumbing_item in plumbing_response.account_resources: 924 yield plumbing.convert_account_resource_to_porcelain( 925 plumbing_item) 926 if plumbing_response.meta.next_cursor == '': 927 break 928 req.meta.cursor = plumbing_response.meta.next_cursor 929 930 return generator(self, req)
AccountResources enumerates the resources to which accounts have access.
The AccountResources service is read-only.
See strongdm.models.AccountResource.
def
list(self, filter, *args, timeout=None)
891 def list(self, filter, *args, timeout=None): 892 ''' 893 List gets a list of AccountResource records matching a given set of criteria. 894 ''' 895 deadline = None if timeout is None else time.time() + timeout 896 req = AccountResourceListRequest() 897 req.meta.CopyFrom(ListRequestMetadata()) 898 if self.parent.page_limit > 0: 899 req.meta.limit = self.parent.page_limit 900 if self.parent.snapshot_datetime is not None: 901 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 902 903 req.filter = plumbing.quote_filter_args(filter, *args) 904 905 def generator(svc, req): 906 tries = 0 907 while True: 908 t = None if deadline is None else deadline - time.time() 909 try: 910 plumbing_response = svc.stub.List( 911 req, 912 metadata=svc.parent.get_metadata( 913 'AccountResources.List', req), 914 timeout=t) 915 except Exception as e: 916 if self.parent.shouldRetry(tries, e, deadline): 917 tries += 1 918 time.sleep( 919 self.parent.exponentialBackoff(tries, deadline)) 920 continue 921 raise plumbing.convert_error_to_porcelain(e) from e 922 tries = 0 923 for plumbing_item in plumbing_response.account_resources: 924 yield plumbing.convert_account_resource_to_porcelain( 925 plumbing_item) 926 if plumbing_response.meta.next_cursor == '': 927 break 928 req.meta.cursor = plumbing_response.meta.next_cursor 929 930 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
933class SnapshotAccountResources: 934 ''' 935 SnapshotAccountResources exposes the read only methods of the AccountResources 936 service for historical queries. 937 ''' 938 def __init__(self, account_resources): 939 self.account_resources = account_resources 940 941 def list(self, filter, *args, timeout=None): 942 ''' 943 List gets a list of AccountResource records matching a given set of criteria. 944 ''' 945 return self.account_resources.list(filter, *args, timeout=timeout)
SnapshotAccountResources exposes the read only methods of the AccountResources service for historical queries.
def
list(self, filter, *args, timeout=None)
941 def list(self, filter, *args, timeout=None): 942 ''' 943 List gets a list of AccountResource records matching a given set of criteria. 944 ''' 945 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
948class AccountResourcesHistory: 949 ''' 950 AccountResourcesHistory records all changes to the state of a AccountResource. 951 See `strongdm.models.AccountResourceHistory`. 952 ''' 953 def __init__(self, channel, client): 954 self.parent = client 955 self.stub = AccountResourcesHistoryStub(channel) 956 957 def list(self, filter, *args, timeout=None): 958 ''' 959 List gets a list of AccountResourceHistory records matching a given set of criteria. 960 ''' 961 deadline = None if timeout is None else time.time() + timeout 962 req = AccountResourceHistoryListRequest() 963 req.meta.CopyFrom(ListRequestMetadata()) 964 if self.parent.page_limit > 0: 965 req.meta.limit = self.parent.page_limit 966 if self.parent.snapshot_datetime is not None: 967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 968 969 req.filter = plumbing.quote_filter_args(filter, *args) 970 971 def generator(svc, req): 972 tries = 0 973 while True: 974 t = None if deadline is None else deadline - time.time() 975 try: 976 plumbing_response = svc.stub.List( 977 req, 978 metadata=svc.parent.get_metadata( 979 'AccountResourcesHistory.List', req), 980 timeout=t) 981 except Exception as e: 982 if self.parent.shouldRetry(tries, e, deadline): 983 tries += 1 984 time.sleep( 985 self.parent.exponentialBackoff(tries, deadline)) 986 continue 987 raise plumbing.convert_error_to_porcelain(e) from e 988 tries = 0 989 for plumbing_item in plumbing_response.history: 990 yield plumbing.convert_account_resource_history_to_porcelain( 991 plumbing_item) 992 if plumbing_response.meta.next_cursor == '': 993 break 994 req.meta.cursor = plumbing_response.meta.next_cursor 995 996 return generator(self, req)
AccountResourcesHistory records all changes to the state of a AccountResource.
See strongdm.models.AccountResourceHistory.
def
list(self, filter, *args, timeout=None)
957 def list(self, filter, *args, timeout=None): 958 ''' 959 List gets a list of AccountResourceHistory records matching a given set of criteria. 960 ''' 961 deadline = None if timeout is None else time.time() + timeout 962 req = AccountResourceHistoryListRequest() 963 req.meta.CopyFrom(ListRequestMetadata()) 964 if self.parent.page_limit > 0: 965 req.meta.limit = self.parent.page_limit 966 if self.parent.snapshot_datetime is not None: 967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 968 969 req.filter = plumbing.quote_filter_args(filter, *args) 970 971 def generator(svc, req): 972 tries = 0 973 while True: 974 t = None if deadline is None else deadline - time.time() 975 try: 976 plumbing_response = svc.stub.List( 977 req, 978 metadata=svc.parent.get_metadata( 979 'AccountResourcesHistory.List', req), 980 timeout=t) 981 except Exception as e: 982 if self.parent.shouldRetry(tries, e, deadline): 983 tries += 1 984 time.sleep( 985 self.parent.exponentialBackoff(tries, deadline)) 986 continue 987 raise plumbing.convert_error_to_porcelain(e) from e 988 tries = 0 989 for plumbing_item in plumbing_response.history: 990 yield plumbing.convert_account_resource_history_to_porcelain( 991 plumbing_item) 992 if plumbing_response.meta.next_cursor == '': 993 break 994 req.meta.cursor = plumbing_response.meta.next_cursor 995 996 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
999class Accounts: 1000 ''' 1001 Accounts are users that have access to strongDM. There are two types of accounts: 1002 1. **Users:** humans who are authenticated through username and password or SSO. 1003 2. **Service Accounts:** machines that are authenticated using a service token. 1004 3. **Tokens** are access keys with permissions that can be used for authentication. 1005 See: 1006 `strongdm.models.Service` 1007 `strongdm.models.Token` 1008 `strongdm.models.User` 1009 ''' 1010 def __init__(self, channel, client): 1011 self.parent = client 1012 self.stub = AccountsStub(channel) 1013 1014 def create(self, account, timeout=None): 1015 ''' 1016 Create registers a new Account. 1017 ''' 1018 deadline = None if timeout is None else time.time() + timeout 1019 req = AccountCreateRequest() 1020 1021 if account is not None: 1022 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1023 tries = 0 1024 plumbing_response = None 1025 while True: 1026 t = None if deadline is None else deadline - time.time() 1027 try: 1028 plumbing_response = self.stub.Create( 1029 req, 1030 metadata=self.parent.get_metadata('Accounts.Create', req), 1031 timeout=t) 1032 except Exception as e: 1033 if self.parent.shouldRetry(tries, e, deadline): 1034 tries += 1 1035 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1036 continue 1037 raise plumbing.convert_error_to_porcelain(e) from e 1038 break 1039 1040 resp = models.AccountCreateResponse() 1041 resp.access_key = (plumbing_response.access_key) 1042 resp.account = plumbing.convert_account_to_porcelain( 1043 plumbing_response.account) 1044 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1045 plumbing_response.meta) 1046 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1047 plumbing_response.rate_limit) 1048 resp.secret_key = (plumbing_response.secret_key) 1049 resp.token = (plumbing_response.token) 1050 return resp 1051 1052 def get(self, id, timeout=None): 1053 ''' 1054 Get reads one Account by ID. 1055 ''' 1056 deadline = None if timeout is None else time.time() + timeout 1057 req = AccountGetRequest() 1058 if self.parent.snapshot_datetime is not None: 1059 req.meta.CopyFrom(GetRequestMetadata()) 1060 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1061 1062 req.id = (id) 1063 tries = 0 1064 plumbing_response = None 1065 while True: 1066 t = None if deadline is None else deadline - time.time() 1067 try: 1068 plumbing_response = self.stub.Get( 1069 req, 1070 metadata=self.parent.get_metadata('Accounts.Get', req), 1071 timeout=t) 1072 except Exception as e: 1073 if self.parent.shouldRetry(tries, e, deadline): 1074 tries += 1 1075 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1076 continue 1077 raise plumbing.convert_error_to_porcelain(e) from e 1078 break 1079 1080 resp = models.AccountGetResponse() 1081 resp.account = plumbing.convert_account_to_porcelain( 1082 plumbing_response.account) 1083 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1084 plumbing_response.meta) 1085 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1086 plumbing_response.rate_limit) 1087 return resp 1088 1089 def update(self, account, timeout=None): 1090 ''' 1091 Update replaces all the fields of an Account by ID. 1092 ''' 1093 deadline = None if timeout is None else time.time() + timeout 1094 req = AccountUpdateRequest() 1095 1096 if account is not None: 1097 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1098 tries = 0 1099 plumbing_response = None 1100 while True: 1101 t = None if deadline is None else deadline - time.time() 1102 try: 1103 plumbing_response = self.stub.Update( 1104 req, 1105 metadata=self.parent.get_metadata('Accounts.Update', req), 1106 timeout=t) 1107 except Exception as e: 1108 if self.parent.shouldRetry(tries, e, deadline): 1109 tries += 1 1110 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1111 continue 1112 raise plumbing.convert_error_to_porcelain(e) from e 1113 break 1114 1115 resp = models.AccountUpdateResponse() 1116 resp.account = plumbing.convert_account_to_porcelain( 1117 plumbing_response.account) 1118 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1119 plumbing_response.meta) 1120 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1121 plumbing_response.rate_limit) 1122 return resp 1123 1124 def delete(self, id, timeout=None): 1125 ''' 1126 Delete removes an Account by ID. 1127 ''' 1128 deadline = None if timeout is None else time.time() + timeout 1129 req = AccountDeleteRequest() 1130 1131 req.id = (id) 1132 tries = 0 1133 plumbing_response = None 1134 while True: 1135 t = None if deadline is None else deadline - time.time() 1136 try: 1137 plumbing_response = self.stub.Delete( 1138 req, 1139 metadata=self.parent.get_metadata('Accounts.Delete', req), 1140 timeout=t) 1141 except Exception as e: 1142 if self.parent.shouldRetry(tries, e, deadline): 1143 tries += 1 1144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1145 continue 1146 raise plumbing.convert_error_to_porcelain(e) from e 1147 break 1148 1149 resp = models.AccountDeleteResponse() 1150 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1151 plumbing_response.meta) 1152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1153 plumbing_response.rate_limit) 1154 return resp 1155 1156 def list(self, filter, *args, timeout=None): 1157 ''' 1158 List gets a list of Accounts matching a given set of criteria. 1159 ''' 1160 deadline = None if timeout is None else time.time() + timeout 1161 req = AccountListRequest() 1162 req.meta.CopyFrom(ListRequestMetadata()) 1163 if self.parent.page_limit > 0: 1164 req.meta.limit = self.parent.page_limit 1165 if self.parent.snapshot_datetime is not None: 1166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1167 1168 req.filter = plumbing.quote_filter_args(filter, *args) 1169 1170 def generator(svc, req): 1171 tries = 0 1172 while True: 1173 t = None if deadline is None else deadline - time.time() 1174 try: 1175 plumbing_response = svc.stub.List( 1176 req, 1177 metadata=svc.parent.get_metadata('Accounts.List', req), 1178 timeout=t) 1179 except Exception as e: 1180 if self.parent.shouldRetry(tries, e, deadline): 1181 tries += 1 1182 time.sleep( 1183 self.parent.exponentialBackoff(tries, deadline)) 1184 continue 1185 raise plumbing.convert_error_to_porcelain(e) from e 1186 tries = 0 1187 for plumbing_item in plumbing_response.accounts: 1188 yield plumbing.convert_account_to_porcelain(plumbing_item) 1189 if plumbing_response.meta.next_cursor == '': 1190 break 1191 req.meta.cursor = plumbing_response.meta.next_cursor 1192 1193 return generator(self, req)
Accounts are users that have access to strongDM. There are two types of accounts:
- Users: humans who are authenticated through username and password or SSO.
- Service Accounts: machines that are authenticated using a service token.
- Tokens are access keys with permissions that can be used for authentication.
See:
strongdm.models.Servicestrongdm.models.Tokenstrongdm.models.User
def
create(self, account, timeout=None)
1014 def create(self, account, timeout=None): 1015 ''' 1016 Create registers a new Account. 1017 ''' 1018 deadline = None if timeout is None else time.time() + timeout 1019 req = AccountCreateRequest() 1020 1021 if account is not None: 1022 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1023 tries = 0 1024 plumbing_response = None 1025 while True: 1026 t = None if deadline is None else deadline - time.time() 1027 try: 1028 plumbing_response = self.stub.Create( 1029 req, 1030 metadata=self.parent.get_metadata('Accounts.Create', req), 1031 timeout=t) 1032 except Exception as e: 1033 if self.parent.shouldRetry(tries, e, deadline): 1034 tries += 1 1035 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1036 continue 1037 raise plumbing.convert_error_to_porcelain(e) from e 1038 break 1039 1040 resp = models.AccountCreateResponse() 1041 resp.access_key = (plumbing_response.access_key) 1042 resp.account = plumbing.convert_account_to_porcelain( 1043 plumbing_response.account) 1044 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1045 plumbing_response.meta) 1046 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1047 plumbing_response.rate_limit) 1048 resp.secret_key = (plumbing_response.secret_key) 1049 resp.token = (plumbing_response.token) 1050 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1052 def get(self, id, timeout=None): 1053 ''' 1054 Get reads one Account by ID. 1055 ''' 1056 deadline = None if timeout is None else time.time() + timeout 1057 req = AccountGetRequest() 1058 if self.parent.snapshot_datetime is not None: 1059 req.meta.CopyFrom(GetRequestMetadata()) 1060 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1061 1062 req.id = (id) 1063 tries = 0 1064 plumbing_response = None 1065 while True: 1066 t = None if deadline is None else deadline - time.time() 1067 try: 1068 plumbing_response = self.stub.Get( 1069 req, 1070 metadata=self.parent.get_metadata('Accounts.Get', req), 1071 timeout=t) 1072 except Exception as e: 1073 if self.parent.shouldRetry(tries, e, deadline): 1074 tries += 1 1075 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1076 continue 1077 raise plumbing.convert_error_to_porcelain(e) from e 1078 break 1079 1080 resp = models.AccountGetResponse() 1081 resp.account = plumbing.convert_account_to_porcelain( 1082 plumbing_response.account) 1083 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1084 plumbing_response.meta) 1085 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1086 plumbing_response.rate_limit) 1087 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1089 def update(self, account, timeout=None): 1090 ''' 1091 Update replaces all the fields of an Account by ID. 1092 ''' 1093 deadline = None if timeout is None else time.time() + timeout 1094 req = AccountUpdateRequest() 1095 1096 if account is not None: 1097 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1098 tries = 0 1099 plumbing_response = None 1100 while True: 1101 t = None if deadline is None else deadline - time.time() 1102 try: 1103 plumbing_response = self.stub.Update( 1104 req, 1105 metadata=self.parent.get_metadata('Accounts.Update', req), 1106 timeout=t) 1107 except Exception as e: 1108 if self.parent.shouldRetry(tries, e, deadline): 1109 tries += 1 1110 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1111 continue 1112 raise plumbing.convert_error_to_porcelain(e) from e 1113 break 1114 1115 resp = models.AccountUpdateResponse() 1116 resp.account = plumbing.convert_account_to_porcelain( 1117 plumbing_response.account) 1118 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1119 plumbing_response.meta) 1120 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1121 plumbing_response.rate_limit) 1122 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1124 def delete(self, id, timeout=None): 1125 ''' 1126 Delete removes an Account by ID. 1127 ''' 1128 deadline = None if timeout is None else time.time() + timeout 1129 req = AccountDeleteRequest() 1130 1131 req.id = (id) 1132 tries = 0 1133 plumbing_response = None 1134 while True: 1135 t = None if deadline is None else deadline - time.time() 1136 try: 1137 plumbing_response = self.stub.Delete( 1138 req, 1139 metadata=self.parent.get_metadata('Accounts.Delete', req), 1140 timeout=t) 1141 except Exception as e: 1142 if self.parent.shouldRetry(tries, e, deadline): 1143 tries += 1 1144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1145 continue 1146 raise plumbing.convert_error_to_porcelain(e) from e 1147 break 1148 1149 resp = models.AccountDeleteResponse() 1150 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1151 plumbing_response.meta) 1152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1153 plumbing_response.rate_limit) 1154 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1156 def list(self, filter, *args, timeout=None): 1157 ''' 1158 List gets a list of Accounts matching a given set of criteria. 1159 ''' 1160 deadline = None if timeout is None else time.time() + timeout 1161 req = AccountListRequest() 1162 req.meta.CopyFrom(ListRequestMetadata()) 1163 if self.parent.page_limit > 0: 1164 req.meta.limit = self.parent.page_limit 1165 if self.parent.snapshot_datetime is not None: 1166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1167 1168 req.filter = plumbing.quote_filter_args(filter, *args) 1169 1170 def generator(svc, req): 1171 tries = 0 1172 while True: 1173 t = None if deadline is None else deadline - time.time() 1174 try: 1175 plumbing_response = svc.stub.List( 1176 req, 1177 metadata=svc.parent.get_metadata('Accounts.List', req), 1178 timeout=t) 1179 except Exception as e: 1180 if self.parent.shouldRetry(tries, e, deadline): 1181 tries += 1 1182 time.sleep( 1183 self.parent.exponentialBackoff(tries, deadline)) 1184 continue 1185 raise plumbing.convert_error_to_porcelain(e) from e 1186 tries = 0 1187 for plumbing_item in plumbing_response.accounts: 1188 yield plumbing.convert_account_to_porcelain(plumbing_item) 1189 if plumbing_response.meta.next_cursor == '': 1190 break 1191 req.meta.cursor = plumbing_response.meta.next_cursor 1192 1193 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1196class SnapshotAccounts: 1197 ''' 1198 SnapshotAccounts exposes the read only methods of the Accounts 1199 service for historical queries. 1200 ''' 1201 def __init__(self, accounts): 1202 self.accounts = accounts 1203 1204 def get(self, id, timeout=None): 1205 ''' 1206 Get reads one Account by ID. 1207 ''' 1208 return self.accounts.get(id, timeout=timeout) 1209 1210 def list(self, filter, *args, timeout=None): 1211 ''' 1212 List gets a list of Accounts matching a given set of criteria. 1213 ''' 1214 return self.accounts.list(filter, *args, timeout=timeout)
SnapshotAccounts exposes the read only methods of the Accounts service for historical queries.
def
get(self, id, timeout=None)
1204 def get(self, id, timeout=None): 1205 ''' 1206 Get reads one Account by ID. 1207 ''' 1208 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1210 def list(self, filter, *args, timeout=None): 1211 ''' 1212 List gets a list of Accounts matching a given set of criteria. 1213 ''' 1214 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1217class AccountsGroups: 1218 ''' 1219 An AccountGroup links an account and a group. 1220 See `strongdm.models.AccountGroup`. 1221 ''' 1222 def __init__(self, channel, client): 1223 self.parent = client 1224 self.stub = AccountsGroupsStub(channel) 1225 1226 def create(self, account_group, timeout=None): 1227 ''' 1228 Create create a new AccountGroup. 1229 ''' 1230 deadline = None if timeout is None else time.time() + timeout 1231 req = AccountGroupCreateRequest() 1232 1233 if account_group is not None: 1234 req.account_group.CopyFrom( 1235 plumbing.convert_account_group_to_plumbing(account_group)) 1236 tries = 0 1237 plumbing_response = None 1238 while True: 1239 t = None if deadline is None else deadline - time.time() 1240 try: 1241 plumbing_response = self.stub.Create( 1242 req, 1243 metadata=self.parent.get_metadata('AccountsGroups.Create', 1244 req), 1245 timeout=t) 1246 except Exception as e: 1247 if self.parent.shouldRetry(tries, e, deadline): 1248 tries += 1 1249 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1250 continue 1251 raise plumbing.convert_error_to_porcelain(e) from e 1252 break 1253 1254 resp = models.AccountGroupCreateResponse() 1255 resp.account_group = plumbing.convert_account_group_to_porcelain( 1256 plumbing_response.account_group) 1257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1258 plumbing_response.rate_limit) 1259 return resp 1260 1261 def get(self, id, timeout=None): 1262 ''' 1263 Get reads one AccountGroup by ID. 1264 ''' 1265 deadline = None if timeout is None else time.time() + timeout 1266 req = AccountGroupGetRequest() 1267 if self.parent.snapshot_datetime is not None: 1268 req.meta.CopyFrom(GetRequestMetadata()) 1269 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1270 1271 req.id = (id) 1272 tries = 0 1273 plumbing_response = None 1274 while True: 1275 t = None if deadline is None else deadline - time.time() 1276 try: 1277 plumbing_response = self.stub.Get( 1278 req, 1279 metadata=self.parent.get_metadata('AccountsGroups.Get', 1280 req), 1281 timeout=t) 1282 except Exception as e: 1283 if self.parent.shouldRetry(tries, e, deadline): 1284 tries += 1 1285 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1286 continue 1287 raise plumbing.convert_error_to_porcelain(e) from e 1288 break 1289 1290 resp = models.AccountGroupGetResponse() 1291 resp.account_group = plumbing.convert_account_group_to_porcelain( 1292 plumbing_response.account_group) 1293 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1294 plumbing_response.meta) 1295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1296 plumbing_response.rate_limit) 1297 return resp 1298 1299 def delete(self, id, timeout=None): 1300 ''' 1301 Delete removes an AccountGroup by ID. 1302 ''' 1303 deadline = None if timeout is None else time.time() + timeout 1304 req = AccountGroupDeleteRequest() 1305 1306 req.id = (id) 1307 tries = 0 1308 plumbing_response = None 1309 while True: 1310 t = None if deadline is None else deadline - time.time() 1311 try: 1312 plumbing_response = self.stub.Delete( 1313 req, 1314 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1315 req), 1316 timeout=t) 1317 except Exception as e: 1318 if self.parent.shouldRetry(tries, e, deadline): 1319 tries += 1 1320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1321 continue 1322 raise plumbing.convert_error_to_porcelain(e) from e 1323 break 1324 1325 resp = models.AccountGroupDeleteResponse() 1326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1327 plumbing_response.meta) 1328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1329 plumbing_response.rate_limit) 1330 return resp 1331 1332 def list(self, filter, *args, timeout=None): 1333 ''' 1334 List gets a list of AccountGroups matching a given set of criteria. 1335 ''' 1336 deadline = None if timeout is None else time.time() + timeout 1337 req = AccountGroupListRequest() 1338 req.meta.CopyFrom(ListRequestMetadata()) 1339 if self.parent.page_limit > 0: 1340 req.meta.limit = self.parent.page_limit 1341 if self.parent.snapshot_datetime is not None: 1342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1343 1344 req.filter = plumbing.quote_filter_args(filter, *args) 1345 1346 def generator(svc, req): 1347 tries = 0 1348 while True: 1349 t = None if deadline is None else deadline - time.time() 1350 try: 1351 plumbing_response = svc.stub.List( 1352 req, 1353 metadata=svc.parent.get_metadata( 1354 'AccountsGroups.List', req), 1355 timeout=t) 1356 except Exception as e: 1357 if self.parent.shouldRetry(tries, e, deadline): 1358 tries += 1 1359 time.sleep( 1360 self.parent.exponentialBackoff(tries, deadline)) 1361 continue 1362 raise plumbing.convert_error_to_porcelain(e) from e 1363 tries = 0 1364 for plumbing_item in plumbing_response.account_groups: 1365 yield plumbing.convert_account_group_to_porcelain( 1366 plumbing_item) 1367 if plumbing_response.meta.next_cursor == '': 1368 break 1369 req.meta.cursor = plumbing_response.meta.next_cursor 1370 1371 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1226 def create(self, account_group, timeout=None): 1227 ''' 1228 Create create a new AccountGroup. 1229 ''' 1230 deadline = None if timeout is None else time.time() + timeout 1231 req = AccountGroupCreateRequest() 1232 1233 if account_group is not None: 1234 req.account_group.CopyFrom( 1235 plumbing.convert_account_group_to_plumbing(account_group)) 1236 tries = 0 1237 plumbing_response = None 1238 while True: 1239 t = None if deadline is None else deadline - time.time() 1240 try: 1241 plumbing_response = self.stub.Create( 1242 req, 1243 metadata=self.parent.get_metadata('AccountsGroups.Create', 1244 req), 1245 timeout=t) 1246 except Exception as e: 1247 if self.parent.shouldRetry(tries, e, deadline): 1248 tries += 1 1249 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1250 continue 1251 raise plumbing.convert_error_to_porcelain(e) from e 1252 break 1253 1254 resp = models.AccountGroupCreateResponse() 1255 resp.account_group = plumbing.convert_account_group_to_porcelain( 1256 plumbing_response.account_group) 1257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1258 plumbing_response.rate_limit) 1259 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1261 def get(self, id, timeout=None): 1262 ''' 1263 Get reads one AccountGroup by ID. 1264 ''' 1265 deadline = None if timeout is None else time.time() + timeout 1266 req = AccountGroupGetRequest() 1267 if self.parent.snapshot_datetime is not None: 1268 req.meta.CopyFrom(GetRequestMetadata()) 1269 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1270 1271 req.id = (id) 1272 tries = 0 1273 plumbing_response = None 1274 while True: 1275 t = None if deadline is None else deadline - time.time() 1276 try: 1277 plumbing_response = self.stub.Get( 1278 req, 1279 metadata=self.parent.get_metadata('AccountsGroups.Get', 1280 req), 1281 timeout=t) 1282 except Exception as e: 1283 if self.parent.shouldRetry(tries, e, deadline): 1284 tries += 1 1285 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1286 continue 1287 raise plumbing.convert_error_to_porcelain(e) from e 1288 break 1289 1290 resp = models.AccountGroupGetResponse() 1291 resp.account_group = plumbing.convert_account_group_to_porcelain( 1292 plumbing_response.account_group) 1293 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1294 plumbing_response.meta) 1295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1296 plumbing_response.rate_limit) 1297 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1299 def delete(self, id, timeout=None): 1300 ''' 1301 Delete removes an AccountGroup by ID. 1302 ''' 1303 deadline = None if timeout is None else time.time() + timeout 1304 req = AccountGroupDeleteRequest() 1305 1306 req.id = (id) 1307 tries = 0 1308 plumbing_response = None 1309 while True: 1310 t = None if deadline is None else deadline - time.time() 1311 try: 1312 plumbing_response = self.stub.Delete( 1313 req, 1314 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1315 req), 1316 timeout=t) 1317 except Exception as e: 1318 if self.parent.shouldRetry(tries, e, deadline): 1319 tries += 1 1320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1321 continue 1322 raise plumbing.convert_error_to_porcelain(e) from e 1323 break 1324 1325 resp = models.AccountGroupDeleteResponse() 1326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1327 plumbing_response.meta) 1328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1329 plumbing_response.rate_limit) 1330 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1332 def list(self, filter, *args, timeout=None): 1333 ''' 1334 List gets a list of AccountGroups matching a given set of criteria. 1335 ''' 1336 deadline = None if timeout is None else time.time() + timeout 1337 req = AccountGroupListRequest() 1338 req.meta.CopyFrom(ListRequestMetadata()) 1339 if self.parent.page_limit > 0: 1340 req.meta.limit = self.parent.page_limit 1341 if self.parent.snapshot_datetime is not None: 1342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1343 1344 req.filter = plumbing.quote_filter_args(filter, *args) 1345 1346 def generator(svc, req): 1347 tries = 0 1348 while True: 1349 t = None if deadline is None else deadline - time.time() 1350 try: 1351 plumbing_response = svc.stub.List( 1352 req, 1353 metadata=svc.parent.get_metadata( 1354 'AccountsGroups.List', req), 1355 timeout=t) 1356 except Exception as e: 1357 if self.parent.shouldRetry(tries, e, deadline): 1358 tries += 1 1359 time.sleep( 1360 self.parent.exponentialBackoff(tries, deadline)) 1361 continue 1362 raise plumbing.convert_error_to_porcelain(e) from e 1363 tries = 0 1364 for plumbing_item in plumbing_response.account_groups: 1365 yield plumbing.convert_account_group_to_porcelain( 1366 plumbing_item) 1367 if plumbing_response.meta.next_cursor == '': 1368 break 1369 req.meta.cursor = plumbing_response.meta.next_cursor 1370 1371 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1374class SnapshotAccountsGroups: 1375 ''' 1376 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1377 service for historical queries. 1378 ''' 1379 def __init__(self, accounts_groups): 1380 self.accounts_groups = accounts_groups 1381 1382 def get(self, id, timeout=None): 1383 ''' 1384 Get reads one AccountGroup by ID. 1385 ''' 1386 return self.accounts_groups.get(id, timeout=timeout) 1387 1388 def list(self, filter, *args, timeout=None): 1389 ''' 1390 List gets a list of AccountGroups matching a given set of criteria. 1391 ''' 1392 return self.accounts_groups.list(filter, *args, timeout=timeout)
SnapshotAccountsGroups exposes the read only methods of the AccountsGroups service for historical queries.
def
get(self, id, timeout=None)
1382 def get(self, id, timeout=None): 1383 ''' 1384 Get reads one AccountGroup by ID. 1385 ''' 1386 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1388 def list(self, filter, *args, timeout=None): 1389 ''' 1390 List gets a list of AccountGroups matching a given set of criteria. 1391 ''' 1392 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1395class AccountsGroupsHistory: 1396 ''' 1397 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1398 See `strongdm.models.AccountGroupHistory`. 1399 ''' 1400 def __init__(self, channel, client): 1401 self.parent = client 1402 self.stub = AccountsGroupsHistoryStub(channel) 1403 1404 def list(self, filter, *args, timeout=None): 1405 ''' 1406 List gets a list of AccountGroupHistory records matching a given set of criteria. 1407 ''' 1408 deadline = None if timeout is None else time.time() + timeout 1409 req = AccountGroupHistoryListRequest() 1410 req.meta.CopyFrom(ListRequestMetadata()) 1411 if self.parent.page_limit > 0: 1412 req.meta.limit = self.parent.page_limit 1413 if self.parent.snapshot_datetime is not None: 1414 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1415 1416 req.filter = plumbing.quote_filter_args(filter, *args) 1417 1418 def generator(svc, req): 1419 tries = 0 1420 while True: 1421 t = None if deadline is None else deadline - time.time() 1422 try: 1423 plumbing_response = svc.stub.List( 1424 req, 1425 metadata=svc.parent.get_metadata( 1426 'AccountsGroupsHistory.List', req), 1427 timeout=t) 1428 except Exception as e: 1429 if self.parent.shouldRetry(tries, e, deadline): 1430 tries += 1 1431 time.sleep( 1432 self.parent.exponentialBackoff(tries, deadline)) 1433 continue 1434 raise plumbing.convert_error_to_porcelain(e) from e 1435 tries = 0 1436 for plumbing_item in plumbing_response.history: 1437 yield plumbing.convert_account_group_history_to_porcelain( 1438 plumbing_item) 1439 if plumbing_response.meta.next_cursor == '': 1440 break 1441 req.meta.cursor = plumbing_response.meta.next_cursor 1442 1443 return generator(self, req)
AccountsGroupsHistory records all changes to the state of an AccountGroup.
See strongdm.models.AccountGroupHistory.
def
list(self, filter, *args, timeout=None)
1404 def list(self, filter, *args, timeout=None): 1405 ''' 1406 List gets a list of AccountGroupHistory records matching a given set of criteria. 1407 ''' 1408 deadline = None if timeout is None else time.time() + timeout 1409 req = AccountGroupHistoryListRequest() 1410 req.meta.CopyFrom(ListRequestMetadata()) 1411 if self.parent.page_limit > 0: 1412 req.meta.limit = self.parent.page_limit 1413 if self.parent.snapshot_datetime is not None: 1414 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1415 1416 req.filter = plumbing.quote_filter_args(filter, *args) 1417 1418 def generator(svc, req): 1419 tries = 0 1420 while True: 1421 t = None if deadline is None else deadline - time.time() 1422 try: 1423 plumbing_response = svc.stub.List( 1424 req, 1425 metadata=svc.parent.get_metadata( 1426 'AccountsGroupsHistory.List', req), 1427 timeout=t) 1428 except Exception as e: 1429 if self.parent.shouldRetry(tries, e, deadline): 1430 tries += 1 1431 time.sleep( 1432 self.parent.exponentialBackoff(tries, deadline)) 1433 continue 1434 raise plumbing.convert_error_to_porcelain(e) from e 1435 tries = 0 1436 for plumbing_item in plumbing_response.history: 1437 yield plumbing.convert_account_group_history_to_porcelain( 1438 plumbing_item) 1439 if plumbing_response.meta.next_cursor == '': 1440 break 1441 req.meta.cursor = plumbing_response.meta.next_cursor 1442 1443 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1446class AccountsHistory: 1447 ''' 1448 AccountsHistory records all changes to the state of an Account. 1449 See `strongdm.models.AccountHistory`. 1450 ''' 1451 def __init__(self, channel, client): 1452 self.parent = client 1453 self.stub = AccountsHistoryStub(channel) 1454 1455 def list(self, filter, *args, timeout=None): 1456 ''' 1457 List gets a list of AccountHistory records matching a given set of criteria. 1458 ''' 1459 deadline = None if timeout is None else time.time() + timeout 1460 req = AccountHistoryListRequest() 1461 req.meta.CopyFrom(ListRequestMetadata()) 1462 if self.parent.page_limit > 0: 1463 req.meta.limit = self.parent.page_limit 1464 if self.parent.snapshot_datetime is not None: 1465 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1466 1467 req.filter = plumbing.quote_filter_args(filter, *args) 1468 1469 def generator(svc, req): 1470 tries = 0 1471 while True: 1472 t = None if deadline is None else deadline - time.time() 1473 try: 1474 plumbing_response = svc.stub.List( 1475 req, 1476 metadata=svc.parent.get_metadata( 1477 'AccountsHistory.List', req), 1478 timeout=t) 1479 except Exception as e: 1480 if self.parent.shouldRetry(tries, e, deadline): 1481 tries += 1 1482 time.sleep( 1483 self.parent.exponentialBackoff(tries, deadline)) 1484 continue 1485 raise plumbing.convert_error_to_porcelain(e) from e 1486 tries = 0 1487 for plumbing_item in plumbing_response.history: 1488 yield plumbing.convert_account_history_to_porcelain( 1489 plumbing_item) 1490 if plumbing_response.meta.next_cursor == '': 1491 break 1492 req.meta.cursor = plumbing_response.meta.next_cursor 1493 1494 return generator(self, req)
AccountsHistory records all changes to the state of an Account.
See strongdm.models.AccountHistory.
def
list(self, filter, *args, timeout=None)
1455 def list(self, filter, *args, timeout=None): 1456 ''' 1457 List gets a list of AccountHistory records matching a given set of criteria. 1458 ''' 1459 deadline = None if timeout is None else time.time() + timeout 1460 req = AccountHistoryListRequest() 1461 req.meta.CopyFrom(ListRequestMetadata()) 1462 if self.parent.page_limit > 0: 1463 req.meta.limit = self.parent.page_limit 1464 if self.parent.snapshot_datetime is not None: 1465 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1466 1467 req.filter = plumbing.quote_filter_args(filter, *args) 1468 1469 def generator(svc, req): 1470 tries = 0 1471 while True: 1472 t = None if deadline is None else deadline - time.time() 1473 try: 1474 plumbing_response = svc.stub.List( 1475 req, 1476 metadata=svc.parent.get_metadata( 1477 'AccountsHistory.List', req), 1478 timeout=t) 1479 except Exception as e: 1480 if self.parent.shouldRetry(tries, e, deadline): 1481 tries += 1 1482 time.sleep( 1483 self.parent.exponentialBackoff(tries, deadline)) 1484 continue 1485 raise plumbing.convert_error_to_porcelain(e) from e 1486 tries = 0 1487 for plumbing_item in plumbing_response.history: 1488 yield plumbing.convert_account_history_to_porcelain( 1489 plumbing_item) 1490 if plumbing_response.meta.next_cursor == '': 1491 break 1492 req.meta.cursor = plumbing_response.meta.next_cursor 1493 1494 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1497class Activities: 1498 ''' 1499 An Activity is a record of an action taken against a strongDM deployment, e.g. 1500 a user creation, resource deletion, sso configuration change, etc. The Activities 1501 service is read-only. 1502 See `strongdm.models.Activity`. 1503 ''' 1504 def __init__(self, channel, client): 1505 self.parent = client 1506 self.stub = ActivitiesStub(channel) 1507 1508 def get(self, id, timeout=None): 1509 ''' 1510 Get reads one Activity by ID. 1511 ''' 1512 deadline = None if timeout is None else time.time() + timeout 1513 req = ActivityGetRequest() 1514 if self.parent.snapshot_datetime is not None: 1515 req.meta.CopyFrom(GetRequestMetadata()) 1516 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1517 1518 req.id = (id) 1519 tries = 0 1520 plumbing_response = None 1521 while True: 1522 t = None if deadline is None else deadline - time.time() 1523 try: 1524 plumbing_response = self.stub.Get( 1525 req, 1526 metadata=self.parent.get_metadata('Activities.Get', req), 1527 timeout=t) 1528 except Exception as e: 1529 if self.parent.shouldRetry(tries, e, deadline): 1530 tries += 1 1531 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1532 continue 1533 raise plumbing.convert_error_to_porcelain(e) from e 1534 break 1535 1536 resp = models.ActivityGetResponse() 1537 resp.activity = plumbing.convert_activity_to_porcelain( 1538 plumbing_response.activity) 1539 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1540 plumbing_response.meta) 1541 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1542 plumbing_response.rate_limit) 1543 return resp 1544 1545 def list(self, filter, *args, timeout=None): 1546 ''' 1547 List gets a list of Activities matching a given set of criteria. 1548 The 'before' and 'after' filters can be used to control the time 1549 range of the output activities. If not provided, one week of back 1550 of activities will be returned. 1551 ''' 1552 deadline = None if timeout is None else time.time() + timeout 1553 req = ActivityListRequest() 1554 req.meta.CopyFrom(ListRequestMetadata()) 1555 if self.parent.page_limit > 0: 1556 req.meta.limit = self.parent.page_limit 1557 if self.parent.snapshot_datetime is not None: 1558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1559 1560 req.filter = plumbing.quote_filter_args(filter, *args) 1561 1562 def generator(svc, req): 1563 tries = 0 1564 while True: 1565 t = None if deadline is None else deadline - time.time() 1566 try: 1567 plumbing_response = svc.stub.List( 1568 req, 1569 metadata=svc.parent.get_metadata( 1570 'Activities.List', req), 1571 timeout=t) 1572 except Exception as e: 1573 if self.parent.shouldRetry(tries, e, deadline): 1574 tries += 1 1575 time.sleep( 1576 self.parent.exponentialBackoff(tries, deadline)) 1577 continue 1578 raise plumbing.convert_error_to_porcelain(e) from e 1579 tries = 0 1580 for plumbing_item in plumbing_response.activities: 1581 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1582 if plumbing_response.meta.next_cursor == '': 1583 break 1584 req.meta.cursor = plumbing_response.meta.next_cursor 1585 1586 return generator(self, req)
An Activity is a record of an action taken against a strongDM deployment, e.g.
a user creation, resource deletion, sso configuration change, etc. The Activities
service is read-only.
See strongdm.models.Activity.
def
get(self, id, timeout=None)
1508 def get(self, id, timeout=None): 1509 ''' 1510 Get reads one Activity by ID. 1511 ''' 1512 deadline = None if timeout is None else time.time() + timeout 1513 req = ActivityGetRequest() 1514 if self.parent.snapshot_datetime is not None: 1515 req.meta.CopyFrom(GetRequestMetadata()) 1516 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1517 1518 req.id = (id) 1519 tries = 0 1520 plumbing_response = None 1521 while True: 1522 t = None if deadline is None else deadline - time.time() 1523 try: 1524 plumbing_response = self.stub.Get( 1525 req, 1526 metadata=self.parent.get_metadata('Activities.Get', req), 1527 timeout=t) 1528 except Exception as e: 1529 if self.parent.shouldRetry(tries, e, deadline): 1530 tries += 1 1531 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1532 continue 1533 raise plumbing.convert_error_to_porcelain(e) from e 1534 break 1535 1536 resp = models.ActivityGetResponse() 1537 resp.activity = plumbing.convert_activity_to_porcelain( 1538 plumbing_response.activity) 1539 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1540 plumbing_response.meta) 1541 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1542 plumbing_response.rate_limit) 1543 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1545 def list(self, filter, *args, timeout=None): 1546 ''' 1547 List gets a list of Activities matching a given set of criteria. 1548 The 'before' and 'after' filters can be used to control the time 1549 range of the output activities. If not provided, one week of back 1550 of activities will be returned. 1551 ''' 1552 deadline = None if timeout is None else time.time() + timeout 1553 req = ActivityListRequest() 1554 req.meta.CopyFrom(ListRequestMetadata()) 1555 if self.parent.page_limit > 0: 1556 req.meta.limit = self.parent.page_limit 1557 if self.parent.snapshot_datetime is not None: 1558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1559 1560 req.filter = plumbing.quote_filter_args(filter, *args) 1561 1562 def generator(svc, req): 1563 tries = 0 1564 while True: 1565 t = None if deadline is None else deadline - time.time() 1566 try: 1567 plumbing_response = svc.stub.List( 1568 req, 1569 metadata=svc.parent.get_metadata( 1570 'Activities.List', req), 1571 timeout=t) 1572 except Exception as e: 1573 if self.parent.shouldRetry(tries, e, deadline): 1574 tries += 1 1575 time.sleep( 1576 self.parent.exponentialBackoff(tries, deadline)) 1577 continue 1578 raise plumbing.convert_error_to_porcelain(e) from e 1579 tries = 0 1580 for plumbing_item in plumbing_response.activities: 1581 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1582 if plumbing_response.meta.next_cursor == '': 1583 break 1584 req.meta.cursor = plumbing_response.meta.next_cursor 1585 1586 return generator(self, req)
List gets a list of Activities matching a given set of criteria. The 'before' and 'after' filters can be used to control the time range of the output activities. If not provided, one week of back of activities will be returned.
class
ApprovalWorkflowApprovers:
1589class ApprovalWorkflowApprovers: 1590 ''' 1591 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1592 See `strongdm.models.ApprovalWorkflowApprover`. 1593 ''' 1594 def __init__(self, channel, client): 1595 self.parent = client 1596 self.stub = ApprovalWorkflowApproversStub(channel) 1597 1598 def create(self, approval_workflow_approver, timeout=None): 1599 ''' 1600 Deprecated: Create creates a new approval workflow approver. 1601 ''' 1602 deadline = None if timeout is None else time.time() + timeout 1603 req = ApprovalWorkflowApproverCreateRequest() 1604 1605 if approval_workflow_approver is not None: 1606 req.approval_workflow_approver.CopyFrom( 1607 plumbing.convert_approval_workflow_approver_to_plumbing( 1608 approval_workflow_approver)) 1609 tries = 0 1610 plumbing_response = None 1611 while True: 1612 t = None if deadline is None else deadline - time.time() 1613 try: 1614 plumbing_response = self.stub.Create( 1615 req, 1616 metadata=self.parent.get_metadata( 1617 'ApprovalWorkflowApprovers.Create', req), 1618 timeout=t) 1619 except Exception as e: 1620 if self.parent.shouldRetry(tries, e, deadline): 1621 tries += 1 1622 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1623 continue 1624 raise plumbing.convert_error_to_porcelain(e) from e 1625 break 1626 1627 resp = models.ApprovalWorkflowApproverCreateResponse() 1628 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1629 plumbing_response.approval_workflow_approver) 1630 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1631 plumbing_response.rate_limit) 1632 return resp 1633 1634 def get(self, id, timeout=None): 1635 ''' 1636 Deprecated: Get reads one approval workflow approver by ID. 1637 ''' 1638 deadline = None if timeout is None else time.time() + timeout 1639 req = ApprovalWorkflowApproverGetRequest() 1640 if self.parent.snapshot_datetime is not None: 1641 req.meta.CopyFrom(GetRequestMetadata()) 1642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1643 1644 req.id = (id) 1645 tries = 0 1646 plumbing_response = None 1647 while True: 1648 t = None if deadline is None else deadline - time.time() 1649 try: 1650 plumbing_response = self.stub.Get( 1651 req, 1652 metadata=self.parent.get_metadata( 1653 'ApprovalWorkflowApprovers.Get', req), 1654 timeout=t) 1655 except Exception as e: 1656 if self.parent.shouldRetry(tries, e, deadline): 1657 tries += 1 1658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1659 continue 1660 raise plumbing.convert_error_to_porcelain(e) from e 1661 break 1662 1663 resp = models.ApprovalWorkflowApproverGetResponse() 1664 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1665 plumbing_response.approval_workflow_approver) 1666 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1667 plumbing_response.meta) 1668 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1669 plumbing_response.rate_limit) 1670 return resp 1671 1672 def delete(self, id, timeout=None): 1673 ''' 1674 Deprecated: Delete deletes an existing approval workflow approver. 1675 ''' 1676 deadline = None if timeout is None else time.time() + timeout 1677 req = ApprovalWorkflowApproverDeleteRequest() 1678 1679 req.id = (id) 1680 tries = 0 1681 plumbing_response = None 1682 while True: 1683 t = None if deadline is None else deadline - time.time() 1684 try: 1685 plumbing_response = self.stub.Delete( 1686 req, 1687 metadata=self.parent.get_metadata( 1688 'ApprovalWorkflowApprovers.Delete', req), 1689 timeout=t) 1690 except Exception as e: 1691 if self.parent.shouldRetry(tries, e, deadline): 1692 tries += 1 1693 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1694 continue 1695 raise plumbing.convert_error_to_porcelain(e) from e 1696 break 1697 1698 resp = models.ApprovalWorkflowApproverDeleteResponse() 1699 resp.id = (plumbing_response.id) 1700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1701 plumbing_response.rate_limit) 1702 return resp 1703 1704 def list(self, filter, *args, timeout=None): 1705 ''' 1706 Deprecated: Lists existing approval workflow approvers. 1707 ''' 1708 deadline = None if timeout is None else time.time() + timeout 1709 req = ApprovalWorkflowApproverListRequest() 1710 req.meta.CopyFrom(ListRequestMetadata()) 1711 if self.parent.page_limit > 0: 1712 req.meta.limit = self.parent.page_limit 1713 if self.parent.snapshot_datetime is not None: 1714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1715 1716 req.filter = plumbing.quote_filter_args(filter, *args) 1717 1718 def generator(svc, req): 1719 tries = 0 1720 while True: 1721 t = None if deadline is None else deadline - time.time() 1722 try: 1723 plumbing_response = svc.stub.List( 1724 req, 1725 metadata=svc.parent.get_metadata( 1726 'ApprovalWorkflowApprovers.List', req), 1727 timeout=t) 1728 except Exception as e: 1729 if self.parent.shouldRetry(tries, e, deadline): 1730 tries += 1 1731 time.sleep( 1732 self.parent.exponentialBackoff(tries, deadline)) 1733 continue 1734 raise plumbing.convert_error_to_porcelain(e) from e 1735 tries = 0 1736 for plumbing_item in plumbing_response.approval_workflow_approvers: 1737 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1738 plumbing_item) 1739 if plumbing_response.meta.next_cursor == '': 1740 break 1741 req.meta.cursor = plumbing_response.meta.next_cursor 1742 1743 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1598 def create(self, approval_workflow_approver, timeout=None): 1599 ''' 1600 Deprecated: Create creates a new approval workflow approver. 1601 ''' 1602 deadline = None if timeout is None else time.time() + timeout 1603 req = ApprovalWorkflowApproverCreateRequest() 1604 1605 if approval_workflow_approver is not None: 1606 req.approval_workflow_approver.CopyFrom( 1607 plumbing.convert_approval_workflow_approver_to_plumbing( 1608 approval_workflow_approver)) 1609 tries = 0 1610 plumbing_response = None 1611 while True: 1612 t = None if deadline is None else deadline - time.time() 1613 try: 1614 plumbing_response = self.stub.Create( 1615 req, 1616 metadata=self.parent.get_metadata( 1617 'ApprovalWorkflowApprovers.Create', req), 1618 timeout=t) 1619 except Exception as e: 1620 if self.parent.shouldRetry(tries, e, deadline): 1621 tries += 1 1622 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1623 continue 1624 raise plumbing.convert_error_to_porcelain(e) from e 1625 break 1626 1627 resp = models.ApprovalWorkflowApproverCreateResponse() 1628 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1629 plumbing_response.approval_workflow_approver) 1630 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1631 plumbing_response.rate_limit) 1632 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1634 def get(self, id, timeout=None): 1635 ''' 1636 Deprecated: Get reads one approval workflow approver by ID. 1637 ''' 1638 deadline = None if timeout is None else time.time() + timeout 1639 req = ApprovalWorkflowApproverGetRequest() 1640 if self.parent.snapshot_datetime is not None: 1641 req.meta.CopyFrom(GetRequestMetadata()) 1642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1643 1644 req.id = (id) 1645 tries = 0 1646 plumbing_response = None 1647 while True: 1648 t = None if deadline is None else deadline - time.time() 1649 try: 1650 plumbing_response = self.stub.Get( 1651 req, 1652 metadata=self.parent.get_metadata( 1653 'ApprovalWorkflowApprovers.Get', req), 1654 timeout=t) 1655 except Exception as e: 1656 if self.parent.shouldRetry(tries, e, deadline): 1657 tries += 1 1658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1659 continue 1660 raise plumbing.convert_error_to_porcelain(e) from e 1661 break 1662 1663 resp = models.ApprovalWorkflowApproverGetResponse() 1664 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1665 plumbing_response.approval_workflow_approver) 1666 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1667 plumbing_response.meta) 1668 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1669 plumbing_response.rate_limit) 1670 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1672 def delete(self, id, timeout=None): 1673 ''' 1674 Deprecated: Delete deletes an existing approval workflow approver. 1675 ''' 1676 deadline = None if timeout is None else time.time() + timeout 1677 req = ApprovalWorkflowApproverDeleteRequest() 1678 1679 req.id = (id) 1680 tries = 0 1681 plumbing_response = None 1682 while True: 1683 t = None if deadline is None else deadline - time.time() 1684 try: 1685 plumbing_response = self.stub.Delete( 1686 req, 1687 metadata=self.parent.get_metadata( 1688 'ApprovalWorkflowApprovers.Delete', req), 1689 timeout=t) 1690 except Exception as e: 1691 if self.parent.shouldRetry(tries, e, deadline): 1692 tries += 1 1693 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1694 continue 1695 raise plumbing.convert_error_to_porcelain(e) from e 1696 break 1697 1698 resp = models.ApprovalWorkflowApproverDeleteResponse() 1699 resp.id = (plumbing_response.id) 1700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1701 plumbing_response.rate_limit) 1702 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1704 def list(self, filter, *args, timeout=None): 1705 ''' 1706 Deprecated: Lists existing approval workflow approvers. 1707 ''' 1708 deadline = None if timeout is None else time.time() + timeout 1709 req = ApprovalWorkflowApproverListRequest() 1710 req.meta.CopyFrom(ListRequestMetadata()) 1711 if self.parent.page_limit > 0: 1712 req.meta.limit = self.parent.page_limit 1713 if self.parent.snapshot_datetime is not None: 1714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1715 1716 req.filter = plumbing.quote_filter_args(filter, *args) 1717 1718 def generator(svc, req): 1719 tries = 0 1720 while True: 1721 t = None if deadline is None else deadline - time.time() 1722 try: 1723 plumbing_response = svc.stub.List( 1724 req, 1725 metadata=svc.parent.get_metadata( 1726 'ApprovalWorkflowApprovers.List', req), 1727 timeout=t) 1728 except Exception as e: 1729 if self.parent.shouldRetry(tries, e, deadline): 1730 tries += 1 1731 time.sleep( 1732 self.parent.exponentialBackoff(tries, deadline)) 1733 continue 1734 raise plumbing.convert_error_to_porcelain(e) from e 1735 tries = 0 1736 for plumbing_item in plumbing_response.approval_workflow_approvers: 1737 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1738 plumbing_item) 1739 if plumbing_response.meta.next_cursor == '': 1740 break 1741 req.meta.cursor = plumbing_response.meta.next_cursor 1742 1743 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1746class SnapshotApprovalWorkflowApprovers: 1747 ''' 1748 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1749 service for historical queries. 1750 ''' 1751 def __init__(self, approval_workflow_approvers): 1752 self.approval_workflow_approvers = approval_workflow_approvers 1753 1754 def get(self, id, timeout=None): 1755 ''' 1756 Deprecated: Get reads one approval workflow approver by ID. 1757 ''' 1758 return self.approval_workflow_approvers.get(id, timeout=timeout) 1759 1760 def list(self, filter, *args, timeout=None): 1761 ''' 1762 Deprecated: Lists existing approval workflow approvers. 1763 ''' 1764 return self.approval_workflow_approvers.list(filter, 1765 *args, 1766 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1754 def get(self, id, timeout=None): 1755 ''' 1756 Deprecated: Get reads one approval workflow approver by ID. 1757 ''' 1758 return self.approval_workflow_approvers.get(id, timeout=timeout)
Deprecated: Get reads one approval workflow approver by ID.
def
list(self, filter, *args, timeout=None)
1760 def list(self, filter, *args, timeout=None): 1761 ''' 1762 Deprecated: Lists existing approval workflow approvers. 1763 ''' 1764 return self.approval_workflow_approvers.list(filter, 1765 *args, 1766 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1769class ApprovalWorkflowApproversHistory: 1770 ''' 1771 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1772 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1773 ''' 1774 def __init__(self, channel, client): 1775 self.parent = client 1776 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1777 1778 def list(self, filter, *args, timeout=None): 1779 ''' 1780 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1781 ''' 1782 deadline = None if timeout is None else time.time() + timeout 1783 req = ApprovalWorkflowApproverHistoryListRequest() 1784 req.meta.CopyFrom(ListRequestMetadata()) 1785 if self.parent.page_limit > 0: 1786 req.meta.limit = self.parent.page_limit 1787 if self.parent.snapshot_datetime is not None: 1788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1789 1790 req.filter = plumbing.quote_filter_args(filter, *args) 1791 1792 def generator(svc, req): 1793 tries = 0 1794 while True: 1795 t = None if deadline is None else deadline - time.time() 1796 try: 1797 plumbing_response = svc.stub.List( 1798 req, 1799 metadata=svc.parent.get_metadata( 1800 'ApprovalWorkflowApproversHistory.List', req), 1801 timeout=t) 1802 except Exception as e: 1803 if self.parent.shouldRetry(tries, e, deadline): 1804 tries += 1 1805 time.sleep( 1806 self.parent.exponentialBackoff(tries, deadline)) 1807 continue 1808 raise plumbing.convert_error_to_porcelain(e) from e 1809 tries = 0 1810 for plumbing_item in plumbing_response.history: 1811 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1812 plumbing_item) 1813 if plumbing_response.meta.next_cursor == '': 1814 break 1815 req.meta.cursor = plumbing_response.meta.next_cursor 1816 1817 return generator(self, req)
ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover.
See strongdm.models.ApprovalWorkflowApproverHistory.
def
list(self, filter, *args, timeout=None)
1778 def list(self, filter, *args, timeout=None): 1779 ''' 1780 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1781 ''' 1782 deadline = None if timeout is None else time.time() + timeout 1783 req = ApprovalWorkflowApproverHistoryListRequest() 1784 req.meta.CopyFrom(ListRequestMetadata()) 1785 if self.parent.page_limit > 0: 1786 req.meta.limit = self.parent.page_limit 1787 if self.parent.snapshot_datetime is not None: 1788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1789 1790 req.filter = plumbing.quote_filter_args(filter, *args) 1791 1792 def generator(svc, req): 1793 tries = 0 1794 while True: 1795 t = None if deadline is None else deadline - time.time() 1796 try: 1797 plumbing_response = svc.stub.List( 1798 req, 1799 metadata=svc.parent.get_metadata( 1800 'ApprovalWorkflowApproversHistory.List', req), 1801 timeout=t) 1802 except Exception as e: 1803 if self.parent.shouldRetry(tries, e, deadline): 1804 tries += 1 1805 time.sleep( 1806 self.parent.exponentialBackoff(tries, deadline)) 1807 continue 1808 raise plumbing.convert_error_to_porcelain(e) from e 1809 tries = 0 1810 for plumbing_item in plumbing_response.history: 1811 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1812 plumbing_item) 1813 if plumbing_response.meta.next_cursor == '': 1814 break 1815 req.meta.cursor = plumbing_response.meta.next_cursor 1816 1817 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1820class ApprovalWorkflowSteps: 1821 ''' 1822 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1823 See `strongdm.models.ApprovalWorkflowStep`. 1824 ''' 1825 def __init__(self, channel, client): 1826 self.parent = client 1827 self.stub = ApprovalWorkflowStepsStub(channel) 1828 1829 def create(self, approval_workflow_step, timeout=None): 1830 ''' 1831 Deprecated: Create creates a new approval workflow step. 1832 ''' 1833 deadline = None if timeout is None else time.time() + timeout 1834 req = ApprovalWorkflowStepCreateRequest() 1835 1836 if approval_workflow_step is not None: 1837 req.approval_workflow_step.CopyFrom( 1838 plumbing.convert_approval_workflow_step_to_plumbing( 1839 approval_workflow_step)) 1840 tries = 0 1841 plumbing_response = None 1842 while True: 1843 t = None if deadline is None else deadline - time.time() 1844 try: 1845 plumbing_response = self.stub.Create( 1846 req, 1847 metadata=self.parent.get_metadata( 1848 'ApprovalWorkflowSteps.Create', req), 1849 timeout=t) 1850 except Exception as e: 1851 if self.parent.shouldRetry(tries, e, deadline): 1852 tries += 1 1853 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1854 continue 1855 raise plumbing.convert_error_to_porcelain(e) from e 1856 break 1857 1858 resp = models.ApprovalWorkflowStepCreateResponse() 1859 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1860 plumbing_response.approval_workflow_step) 1861 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1862 plumbing_response.rate_limit) 1863 return resp 1864 1865 def get(self, id, timeout=None): 1866 ''' 1867 Deprecated: Get reads one approval workflow step by ID. 1868 ''' 1869 deadline = None if timeout is None else time.time() + timeout 1870 req = ApprovalWorkflowStepGetRequest() 1871 if self.parent.snapshot_datetime is not None: 1872 req.meta.CopyFrom(GetRequestMetadata()) 1873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1874 1875 req.id = (id) 1876 tries = 0 1877 plumbing_response = None 1878 while True: 1879 t = None if deadline is None else deadline - time.time() 1880 try: 1881 plumbing_response = self.stub.Get( 1882 req, 1883 metadata=self.parent.get_metadata( 1884 'ApprovalWorkflowSteps.Get', req), 1885 timeout=t) 1886 except Exception as e: 1887 if self.parent.shouldRetry(tries, e, deadline): 1888 tries += 1 1889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1890 continue 1891 raise plumbing.convert_error_to_porcelain(e) from e 1892 break 1893 1894 resp = models.ApprovalWorkflowStepGetResponse() 1895 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1896 plumbing_response.approval_workflow_step) 1897 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1898 plumbing_response.meta) 1899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1900 plumbing_response.rate_limit) 1901 return resp 1902 1903 def delete(self, id, timeout=None): 1904 ''' 1905 Deprecated: Delete deletes an existing approval workflow step. 1906 ''' 1907 deadline = None if timeout is None else time.time() + timeout 1908 req = ApprovalWorkflowStepDeleteRequest() 1909 1910 req.id = (id) 1911 tries = 0 1912 plumbing_response = None 1913 while True: 1914 t = None if deadline is None else deadline - time.time() 1915 try: 1916 plumbing_response = self.stub.Delete( 1917 req, 1918 metadata=self.parent.get_metadata( 1919 'ApprovalWorkflowSteps.Delete', req), 1920 timeout=t) 1921 except Exception as e: 1922 if self.parent.shouldRetry(tries, e, deadline): 1923 tries += 1 1924 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1925 continue 1926 raise plumbing.convert_error_to_porcelain(e) from e 1927 break 1928 1929 resp = models.ApprovalWorkflowStepDeleteResponse() 1930 resp.id = (plumbing_response.id) 1931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1932 plumbing_response.rate_limit) 1933 return resp 1934 1935 def list(self, filter, *args, timeout=None): 1936 ''' 1937 Deprecated: Lists existing approval workflow steps. 1938 ''' 1939 deadline = None if timeout is None else time.time() + timeout 1940 req = ApprovalWorkflowStepListRequest() 1941 req.meta.CopyFrom(ListRequestMetadata()) 1942 if self.parent.page_limit > 0: 1943 req.meta.limit = self.parent.page_limit 1944 if self.parent.snapshot_datetime is not None: 1945 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1946 1947 req.filter = plumbing.quote_filter_args(filter, *args) 1948 1949 def generator(svc, req): 1950 tries = 0 1951 while True: 1952 t = None if deadline is None else deadline - time.time() 1953 try: 1954 plumbing_response = svc.stub.List( 1955 req, 1956 metadata=svc.parent.get_metadata( 1957 'ApprovalWorkflowSteps.List', req), 1958 timeout=t) 1959 except Exception as e: 1960 if self.parent.shouldRetry(tries, e, deadline): 1961 tries += 1 1962 time.sleep( 1963 self.parent.exponentialBackoff(tries, deadline)) 1964 continue 1965 raise plumbing.convert_error_to_porcelain(e) from e 1966 tries = 0 1967 for plumbing_item in plumbing_response.approval_workflow_steps: 1968 yield plumbing.convert_approval_workflow_step_to_porcelain( 1969 plumbing_item) 1970 if plumbing_response.meta.next_cursor == '': 1971 break 1972 req.meta.cursor = plumbing_response.meta.next_cursor 1973 1974 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1829 def create(self, approval_workflow_step, timeout=None): 1830 ''' 1831 Deprecated: Create creates a new approval workflow step. 1832 ''' 1833 deadline = None if timeout is None else time.time() + timeout 1834 req = ApprovalWorkflowStepCreateRequest() 1835 1836 if approval_workflow_step is not None: 1837 req.approval_workflow_step.CopyFrom( 1838 plumbing.convert_approval_workflow_step_to_plumbing( 1839 approval_workflow_step)) 1840 tries = 0 1841 plumbing_response = None 1842 while True: 1843 t = None if deadline is None else deadline - time.time() 1844 try: 1845 plumbing_response = self.stub.Create( 1846 req, 1847 metadata=self.parent.get_metadata( 1848 'ApprovalWorkflowSteps.Create', req), 1849 timeout=t) 1850 except Exception as e: 1851 if self.parent.shouldRetry(tries, e, deadline): 1852 tries += 1 1853 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1854 continue 1855 raise plumbing.convert_error_to_porcelain(e) from e 1856 break 1857 1858 resp = models.ApprovalWorkflowStepCreateResponse() 1859 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1860 plumbing_response.approval_workflow_step) 1861 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1862 plumbing_response.rate_limit) 1863 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1865 def get(self, id, timeout=None): 1866 ''' 1867 Deprecated: Get reads one approval workflow step by ID. 1868 ''' 1869 deadline = None if timeout is None else time.time() + timeout 1870 req = ApprovalWorkflowStepGetRequest() 1871 if self.parent.snapshot_datetime is not None: 1872 req.meta.CopyFrom(GetRequestMetadata()) 1873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1874 1875 req.id = (id) 1876 tries = 0 1877 plumbing_response = None 1878 while True: 1879 t = None if deadline is None else deadline - time.time() 1880 try: 1881 plumbing_response = self.stub.Get( 1882 req, 1883 metadata=self.parent.get_metadata( 1884 'ApprovalWorkflowSteps.Get', req), 1885 timeout=t) 1886 except Exception as e: 1887 if self.parent.shouldRetry(tries, e, deadline): 1888 tries += 1 1889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1890 continue 1891 raise plumbing.convert_error_to_porcelain(e) from e 1892 break 1893 1894 resp = models.ApprovalWorkflowStepGetResponse() 1895 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1896 plumbing_response.approval_workflow_step) 1897 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1898 plumbing_response.meta) 1899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1900 plumbing_response.rate_limit) 1901 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1903 def delete(self, id, timeout=None): 1904 ''' 1905 Deprecated: Delete deletes an existing approval workflow step. 1906 ''' 1907 deadline = None if timeout is None else time.time() + timeout 1908 req = ApprovalWorkflowStepDeleteRequest() 1909 1910 req.id = (id) 1911 tries = 0 1912 plumbing_response = None 1913 while True: 1914 t = None if deadline is None else deadline - time.time() 1915 try: 1916 plumbing_response = self.stub.Delete( 1917 req, 1918 metadata=self.parent.get_metadata( 1919 'ApprovalWorkflowSteps.Delete', req), 1920 timeout=t) 1921 except Exception as e: 1922 if self.parent.shouldRetry(tries, e, deadline): 1923 tries += 1 1924 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1925 continue 1926 raise plumbing.convert_error_to_porcelain(e) from e 1927 break 1928 1929 resp = models.ApprovalWorkflowStepDeleteResponse() 1930 resp.id = (plumbing_response.id) 1931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1932 plumbing_response.rate_limit) 1933 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1935 def list(self, filter, *args, timeout=None): 1936 ''' 1937 Deprecated: Lists existing approval workflow steps. 1938 ''' 1939 deadline = None if timeout is None else time.time() + timeout 1940 req = ApprovalWorkflowStepListRequest() 1941 req.meta.CopyFrom(ListRequestMetadata()) 1942 if self.parent.page_limit > 0: 1943 req.meta.limit = self.parent.page_limit 1944 if self.parent.snapshot_datetime is not None: 1945 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1946 1947 req.filter = plumbing.quote_filter_args(filter, *args) 1948 1949 def generator(svc, req): 1950 tries = 0 1951 while True: 1952 t = None if deadline is None else deadline - time.time() 1953 try: 1954 plumbing_response = svc.stub.List( 1955 req, 1956 metadata=svc.parent.get_metadata( 1957 'ApprovalWorkflowSteps.List', req), 1958 timeout=t) 1959 except Exception as e: 1960 if self.parent.shouldRetry(tries, e, deadline): 1961 tries += 1 1962 time.sleep( 1963 self.parent.exponentialBackoff(tries, deadline)) 1964 continue 1965 raise plumbing.convert_error_to_porcelain(e) from e 1966 tries = 0 1967 for plumbing_item in plumbing_response.approval_workflow_steps: 1968 yield plumbing.convert_approval_workflow_step_to_porcelain( 1969 plumbing_item) 1970 if plumbing_response.meta.next_cursor == '': 1971 break 1972 req.meta.cursor = plumbing_response.meta.next_cursor 1973 1974 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1977class SnapshotApprovalWorkflowSteps: 1978 ''' 1979 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1980 service for historical queries. 1981 ''' 1982 def __init__(self, approval_workflow_steps): 1983 self.approval_workflow_steps = approval_workflow_steps 1984 1985 def get(self, id, timeout=None): 1986 ''' 1987 Deprecated: Get reads one approval workflow step by ID. 1988 ''' 1989 return self.approval_workflow_steps.get(id, timeout=timeout) 1990 1991 def list(self, filter, *args, timeout=None): 1992 ''' 1993 Deprecated: Lists existing approval workflow steps. 1994 ''' 1995 return self.approval_workflow_steps.list(filter, 1996 *args, 1997 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1985 def get(self, id, timeout=None): 1986 ''' 1987 Deprecated: Get reads one approval workflow step by ID. 1988 ''' 1989 return self.approval_workflow_steps.get(id, timeout=timeout)
Deprecated: Get reads one approval workflow step by ID.
def
list(self, filter, *args, timeout=None)
1991 def list(self, filter, *args, timeout=None): 1992 ''' 1993 Deprecated: Lists existing approval workflow steps. 1994 ''' 1995 return self.approval_workflow_steps.list(filter, 1996 *args, 1997 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2000class ApprovalWorkflowStepsHistory: 2001 ''' 2002 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2003 See `strongdm.models.ApprovalWorkflowStepHistory`. 2004 ''' 2005 def __init__(self, channel, client): 2006 self.parent = client 2007 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2008 2009 def list(self, filter, *args, timeout=None): 2010 ''' 2011 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2012 ''' 2013 deadline = None if timeout is None else time.time() + timeout 2014 req = ApprovalWorkflowStepHistoryListRequest() 2015 req.meta.CopyFrom(ListRequestMetadata()) 2016 if self.parent.page_limit > 0: 2017 req.meta.limit = self.parent.page_limit 2018 if self.parent.snapshot_datetime is not None: 2019 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2020 2021 req.filter = plumbing.quote_filter_args(filter, *args) 2022 2023 def generator(svc, req): 2024 tries = 0 2025 while True: 2026 t = None if deadline is None else deadline - time.time() 2027 try: 2028 plumbing_response = svc.stub.List( 2029 req, 2030 metadata=svc.parent.get_metadata( 2031 'ApprovalWorkflowStepsHistory.List', req), 2032 timeout=t) 2033 except Exception as e: 2034 if self.parent.shouldRetry(tries, e, deadline): 2035 tries += 1 2036 time.sleep( 2037 self.parent.exponentialBackoff(tries, deadline)) 2038 continue 2039 raise plumbing.convert_error_to_porcelain(e) from e 2040 tries = 0 2041 for plumbing_item in plumbing_response.history: 2042 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2043 plumbing_item) 2044 if plumbing_response.meta.next_cursor == '': 2045 break 2046 req.meta.cursor = plumbing_response.meta.next_cursor 2047 2048 return generator(self, req)
ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep.
See strongdm.models.ApprovalWorkflowStepHistory.
def
list(self, filter, *args, timeout=None)
2009 def list(self, filter, *args, timeout=None): 2010 ''' 2011 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2012 ''' 2013 deadline = None if timeout is None else time.time() + timeout 2014 req = ApprovalWorkflowStepHistoryListRequest() 2015 req.meta.CopyFrom(ListRequestMetadata()) 2016 if self.parent.page_limit > 0: 2017 req.meta.limit = self.parent.page_limit 2018 if self.parent.snapshot_datetime is not None: 2019 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2020 2021 req.filter = plumbing.quote_filter_args(filter, *args) 2022 2023 def generator(svc, req): 2024 tries = 0 2025 while True: 2026 t = None if deadline is None else deadline - time.time() 2027 try: 2028 plumbing_response = svc.stub.List( 2029 req, 2030 metadata=svc.parent.get_metadata( 2031 'ApprovalWorkflowStepsHistory.List', req), 2032 timeout=t) 2033 except Exception as e: 2034 if self.parent.shouldRetry(tries, e, deadline): 2035 tries += 1 2036 time.sleep( 2037 self.parent.exponentialBackoff(tries, deadline)) 2038 continue 2039 raise plumbing.convert_error_to_porcelain(e) from e 2040 tries = 0 2041 for plumbing_item in plumbing_response.history: 2042 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2043 plumbing_item) 2044 if plumbing_response.meta.next_cursor == '': 2045 break 2046 req.meta.cursor = plumbing_response.meta.next_cursor 2047 2048 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2051class ApprovalWorkflows: 2052 ''' 2053 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2054 approvers and be approved or denied. 2055 See `strongdm.models.ApprovalWorkflow`. 2056 ''' 2057 def __init__(self, channel, client): 2058 self.parent = client 2059 self.stub = ApprovalWorkflowsStub(channel) 2060 2061 def create(self, approval_workflow, timeout=None): 2062 ''' 2063 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2064 ''' 2065 deadline = None if timeout is None else time.time() + timeout 2066 req = ApprovalWorkflowCreateRequest() 2067 2068 if approval_workflow is not None: 2069 req.approval_workflow.CopyFrom( 2070 plumbing.convert_approval_workflow_to_plumbing( 2071 approval_workflow)) 2072 tries = 0 2073 plumbing_response = None 2074 while True: 2075 t = None if deadline is None else deadline - time.time() 2076 try: 2077 plumbing_response = self.stub.Create( 2078 req, 2079 metadata=self.parent.get_metadata( 2080 'ApprovalWorkflows.Create', req), 2081 timeout=t) 2082 except Exception as e: 2083 if self.parent.shouldRetry(tries, e, deadline): 2084 tries += 1 2085 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2086 continue 2087 raise plumbing.convert_error_to_porcelain(e) from e 2088 break 2089 2090 resp = models.ApprovalWorkflowCreateResponse() 2091 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2092 plumbing_response.approval_workflow) 2093 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2094 plumbing_response.rate_limit) 2095 return resp 2096 2097 def get(self, id, timeout=None): 2098 ''' 2099 Get reads one approval workflow by ID. 2100 ''' 2101 deadline = None if timeout is None else time.time() + timeout 2102 req = ApprovalWorkflowGetRequest() 2103 if self.parent.snapshot_datetime is not None: 2104 req.meta.CopyFrom(GetRequestMetadata()) 2105 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2106 2107 req.id = (id) 2108 tries = 0 2109 plumbing_response = None 2110 while True: 2111 t = None if deadline is None else deadline - time.time() 2112 try: 2113 plumbing_response = self.stub.Get( 2114 req, 2115 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2116 req), 2117 timeout=t) 2118 except Exception as e: 2119 if self.parent.shouldRetry(tries, e, deadline): 2120 tries += 1 2121 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2122 continue 2123 raise plumbing.convert_error_to_porcelain(e) from e 2124 break 2125 2126 resp = models.ApprovalWorkflowGetResponse() 2127 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2128 plumbing_response.approval_workflow) 2129 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2130 plumbing_response.meta) 2131 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2132 plumbing_response.rate_limit) 2133 return resp 2134 2135 def delete(self, id, timeout=None): 2136 ''' 2137 Delete deletes an existing approval workflow. 2138 ''' 2139 deadline = None if timeout is None else time.time() + timeout 2140 req = ApprovalWorkflowDeleteRequest() 2141 2142 req.id = (id) 2143 tries = 0 2144 plumbing_response = None 2145 while True: 2146 t = None if deadline is None else deadline - time.time() 2147 try: 2148 plumbing_response = self.stub.Delete( 2149 req, 2150 metadata=self.parent.get_metadata( 2151 'ApprovalWorkflows.Delete', req), 2152 timeout=t) 2153 except Exception as e: 2154 if self.parent.shouldRetry(tries, e, deadline): 2155 tries += 1 2156 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2157 continue 2158 raise plumbing.convert_error_to_porcelain(e) from e 2159 break 2160 2161 resp = models.ApprovalWorkflowDeleteResponse() 2162 resp.id = (plumbing_response.id) 2163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2164 plumbing_response.rate_limit) 2165 return resp 2166 2167 def update(self, approval_workflow, timeout=None): 2168 ''' 2169 Update updates an existing approval workflow. 2170 ''' 2171 deadline = None if timeout is None else time.time() + timeout 2172 req = ApprovalWorkflowUpdateRequest() 2173 2174 if approval_workflow is not None: 2175 req.approval_workflow.CopyFrom( 2176 plumbing.convert_approval_workflow_to_plumbing( 2177 approval_workflow)) 2178 tries = 0 2179 plumbing_response = None 2180 while True: 2181 t = None if deadline is None else deadline - time.time() 2182 try: 2183 plumbing_response = self.stub.Update( 2184 req, 2185 metadata=self.parent.get_metadata( 2186 'ApprovalWorkflows.Update', req), 2187 timeout=t) 2188 except Exception as e: 2189 if self.parent.shouldRetry(tries, e, deadline): 2190 tries += 1 2191 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2192 continue 2193 raise plumbing.convert_error_to_porcelain(e) from e 2194 break 2195 2196 resp = models.ApprovalWorkflowUpdateResponse() 2197 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2198 plumbing_response.approval_workflow) 2199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2200 plumbing_response.rate_limit) 2201 return resp 2202 2203 def list(self, filter, *args, timeout=None): 2204 ''' 2205 Lists existing approval workflows. 2206 ''' 2207 deadline = None if timeout is None else time.time() + timeout 2208 req = ApprovalWorkflowListRequest() 2209 req.meta.CopyFrom(ListRequestMetadata()) 2210 if self.parent.page_limit > 0: 2211 req.meta.limit = self.parent.page_limit 2212 if self.parent.snapshot_datetime is not None: 2213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2214 2215 req.filter = plumbing.quote_filter_args(filter, *args) 2216 2217 def generator(svc, req): 2218 tries = 0 2219 while True: 2220 t = None if deadline is None else deadline - time.time() 2221 try: 2222 plumbing_response = svc.stub.List( 2223 req, 2224 metadata=svc.parent.get_metadata( 2225 'ApprovalWorkflows.List', req), 2226 timeout=t) 2227 except Exception as e: 2228 if self.parent.shouldRetry(tries, e, deadline): 2229 tries += 1 2230 time.sleep( 2231 self.parent.exponentialBackoff(tries, deadline)) 2232 continue 2233 raise plumbing.convert_error_to_porcelain(e) from e 2234 tries = 0 2235 for plumbing_item in plumbing_response.approval_workflows: 2236 yield plumbing.convert_approval_workflow_to_porcelain( 2237 plumbing_item) 2238 if plumbing_response.meta.next_cursor == '': 2239 break 2240 req.meta.cursor = plumbing_response.meta.next_cursor 2241 2242 return generator(self, req)
ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized
approvers and be approved or denied.
See strongdm.models.ApprovalWorkflow.
def
create(self, approval_workflow, timeout=None)
2061 def create(self, approval_workflow, timeout=None): 2062 ''' 2063 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2064 ''' 2065 deadline = None if timeout is None else time.time() + timeout 2066 req = ApprovalWorkflowCreateRequest() 2067 2068 if approval_workflow is not None: 2069 req.approval_workflow.CopyFrom( 2070 plumbing.convert_approval_workflow_to_plumbing( 2071 approval_workflow)) 2072 tries = 0 2073 plumbing_response = None 2074 while True: 2075 t = None if deadline is None else deadline - time.time() 2076 try: 2077 plumbing_response = self.stub.Create( 2078 req, 2079 metadata=self.parent.get_metadata( 2080 'ApprovalWorkflows.Create', req), 2081 timeout=t) 2082 except Exception as e: 2083 if self.parent.shouldRetry(tries, e, deadline): 2084 tries += 1 2085 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2086 continue 2087 raise plumbing.convert_error_to_porcelain(e) from e 2088 break 2089 2090 resp = models.ApprovalWorkflowCreateResponse() 2091 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2092 plumbing_response.approval_workflow) 2093 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2094 plumbing_response.rate_limit) 2095 return resp
Create creates a new approval workflow and requires a name and approval mode for the approval workflow.
def
get(self, id, timeout=None)
2097 def get(self, id, timeout=None): 2098 ''' 2099 Get reads one approval workflow by ID. 2100 ''' 2101 deadline = None if timeout is None else time.time() + timeout 2102 req = ApprovalWorkflowGetRequest() 2103 if self.parent.snapshot_datetime is not None: 2104 req.meta.CopyFrom(GetRequestMetadata()) 2105 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2106 2107 req.id = (id) 2108 tries = 0 2109 plumbing_response = None 2110 while True: 2111 t = None if deadline is None else deadline - time.time() 2112 try: 2113 plumbing_response = self.stub.Get( 2114 req, 2115 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2116 req), 2117 timeout=t) 2118 except Exception as e: 2119 if self.parent.shouldRetry(tries, e, deadline): 2120 tries += 1 2121 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2122 continue 2123 raise plumbing.convert_error_to_porcelain(e) from e 2124 break 2125 2126 resp = models.ApprovalWorkflowGetResponse() 2127 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2128 plumbing_response.approval_workflow) 2129 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2130 plumbing_response.meta) 2131 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2132 plumbing_response.rate_limit) 2133 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2135 def delete(self, id, timeout=None): 2136 ''' 2137 Delete deletes an existing approval workflow. 2138 ''' 2139 deadline = None if timeout is None else time.time() + timeout 2140 req = ApprovalWorkflowDeleteRequest() 2141 2142 req.id = (id) 2143 tries = 0 2144 plumbing_response = None 2145 while True: 2146 t = None if deadline is None else deadline - time.time() 2147 try: 2148 plumbing_response = self.stub.Delete( 2149 req, 2150 metadata=self.parent.get_metadata( 2151 'ApprovalWorkflows.Delete', req), 2152 timeout=t) 2153 except Exception as e: 2154 if self.parent.shouldRetry(tries, e, deadline): 2155 tries += 1 2156 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2157 continue 2158 raise plumbing.convert_error_to_porcelain(e) from e 2159 break 2160 2161 resp = models.ApprovalWorkflowDeleteResponse() 2162 resp.id = (plumbing_response.id) 2163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2164 plumbing_response.rate_limit) 2165 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2167 def update(self, approval_workflow, timeout=None): 2168 ''' 2169 Update updates an existing approval workflow. 2170 ''' 2171 deadline = None if timeout is None else time.time() + timeout 2172 req = ApprovalWorkflowUpdateRequest() 2173 2174 if approval_workflow is not None: 2175 req.approval_workflow.CopyFrom( 2176 plumbing.convert_approval_workflow_to_plumbing( 2177 approval_workflow)) 2178 tries = 0 2179 plumbing_response = None 2180 while True: 2181 t = None if deadline is None else deadline - time.time() 2182 try: 2183 plumbing_response = self.stub.Update( 2184 req, 2185 metadata=self.parent.get_metadata( 2186 'ApprovalWorkflows.Update', req), 2187 timeout=t) 2188 except Exception as e: 2189 if self.parent.shouldRetry(tries, e, deadline): 2190 tries += 1 2191 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2192 continue 2193 raise plumbing.convert_error_to_porcelain(e) from e 2194 break 2195 2196 resp = models.ApprovalWorkflowUpdateResponse() 2197 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2198 plumbing_response.approval_workflow) 2199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2200 plumbing_response.rate_limit) 2201 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2203 def list(self, filter, *args, timeout=None): 2204 ''' 2205 Lists existing approval workflows. 2206 ''' 2207 deadline = None if timeout is None else time.time() + timeout 2208 req = ApprovalWorkflowListRequest() 2209 req.meta.CopyFrom(ListRequestMetadata()) 2210 if self.parent.page_limit > 0: 2211 req.meta.limit = self.parent.page_limit 2212 if self.parent.snapshot_datetime is not None: 2213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2214 2215 req.filter = plumbing.quote_filter_args(filter, *args) 2216 2217 def generator(svc, req): 2218 tries = 0 2219 while True: 2220 t = None if deadline is None else deadline - time.time() 2221 try: 2222 plumbing_response = svc.stub.List( 2223 req, 2224 metadata=svc.parent.get_metadata( 2225 'ApprovalWorkflows.List', req), 2226 timeout=t) 2227 except Exception as e: 2228 if self.parent.shouldRetry(tries, e, deadline): 2229 tries += 1 2230 time.sleep( 2231 self.parent.exponentialBackoff(tries, deadline)) 2232 continue 2233 raise plumbing.convert_error_to_porcelain(e) from e 2234 tries = 0 2235 for plumbing_item in plumbing_response.approval_workflows: 2236 yield plumbing.convert_approval_workflow_to_porcelain( 2237 plumbing_item) 2238 if plumbing_response.meta.next_cursor == '': 2239 break 2240 req.meta.cursor = plumbing_response.meta.next_cursor 2241 2242 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2245class SnapshotApprovalWorkflows: 2246 ''' 2247 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2248 service for historical queries. 2249 ''' 2250 def __init__(self, approval_workflows): 2251 self.approval_workflows = approval_workflows 2252 2253 def get(self, id, timeout=None): 2254 ''' 2255 Get reads one approval workflow by ID. 2256 ''' 2257 return self.approval_workflows.get(id, timeout=timeout) 2258 2259 def list(self, filter, *args, timeout=None): 2260 ''' 2261 Lists existing approval workflows. 2262 ''' 2263 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2266class ApprovalWorkflowsHistory: 2267 ''' 2268 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2269 See `strongdm.models.ApprovalWorkflowHistory`. 2270 ''' 2271 def __init__(self, channel, client): 2272 self.parent = client 2273 self.stub = ApprovalWorkflowsHistoryStub(channel) 2274 2275 def list(self, filter, *args, timeout=None): 2276 ''' 2277 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2278 ''' 2279 deadline = None if timeout is None else time.time() + timeout 2280 req = ApprovalWorkflowHistoryListRequest() 2281 req.meta.CopyFrom(ListRequestMetadata()) 2282 if self.parent.page_limit > 0: 2283 req.meta.limit = self.parent.page_limit 2284 if self.parent.snapshot_datetime is not None: 2285 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2286 2287 req.filter = plumbing.quote_filter_args(filter, *args) 2288 2289 def generator(svc, req): 2290 tries = 0 2291 while True: 2292 t = None if deadline is None else deadline - time.time() 2293 try: 2294 plumbing_response = svc.stub.List( 2295 req, 2296 metadata=svc.parent.get_metadata( 2297 'ApprovalWorkflowsHistory.List', req), 2298 timeout=t) 2299 except Exception as e: 2300 if self.parent.shouldRetry(tries, e, deadline): 2301 tries += 1 2302 time.sleep( 2303 self.parent.exponentialBackoff(tries, deadline)) 2304 continue 2305 raise plumbing.convert_error_to_porcelain(e) from e 2306 tries = 0 2307 for plumbing_item in plumbing_response.history: 2308 yield plumbing.convert_approval_workflow_history_to_porcelain( 2309 plumbing_item) 2310 if plumbing_response.meta.next_cursor == '': 2311 break 2312 req.meta.cursor = plumbing_response.meta.next_cursor 2313 2314 return generator(self, req)
ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow.
See strongdm.models.ApprovalWorkflowHistory.
def
list(self, filter, *args, timeout=None)
2275 def list(self, filter, *args, timeout=None): 2276 ''' 2277 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2278 ''' 2279 deadline = None if timeout is None else time.time() + timeout 2280 req = ApprovalWorkflowHistoryListRequest() 2281 req.meta.CopyFrom(ListRequestMetadata()) 2282 if self.parent.page_limit > 0: 2283 req.meta.limit = self.parent.page_limit 2284 if self.parent.snapshot_datetime is not None: 2285 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2286 2287 req.filter = plumbing.quote_filter_args(filter, *args) 2288 2289 def generator(svc, req): 2290 tries = 0 2291 while True: 2292 t = None if deadline is None else deadline - time.time() 2293 try: 2294 plumbing_response = svc.stub.List( 2295 req, 2296 metadata=svc.parent.get_metadata( 2297 'ApprovalWorkflowsHistory.List', req), 2298 timeout=t) 2299 except Exception as e: 2300 if self.parent.shouldRetry(tries, e, deadline): 2301 tries += 1 2302 time.sleep( 2303 self.parent.exponentialBackoff(tries, deadline)) 2304 continue 2305 raise plumbing.convert_error_to_porcelain(e) from e 2306 tries = 0 2307 for plumbing_item in plumbing_response.history: 2308 yield plumbing.convert_approval_workflow_history_to_porcelain( 2309 plumbing_item) 2310 if plumbing_response.meta.next_cursor == '': 2311 break 2312 req.meta.cursor = plumbing_response.meta.next_cursor 2313 2314 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2317class ControlPanel: 2318 ''' 2319 ControlPanel contains all administrative controls. 2320 ''' 2321 def __init__(self, channel, client): 2322 self.parent = client 2323 self.stub = ControlPanelStub(channel) 2324 2325 def get_sshca_public_key(self, timeout=None): 2326 ''' 2327 GetSSHCAPublicKey retrieves the SSH CA public key. 2328 ''' 2329 deadline = None if timeout is None else time.time() + timeout 2330 req = ControlPanelGetSSHCAPublicKeyRequest() 2331 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.GetSSHCAPublicKey( 2338 req, 2339 metadata=self.parent.get_metadata( 2340 'ControlPanel.GetSSHCAPublicKey', req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2351 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2352 plumbing_response.meta) 2353 resp.public_key = (plumbing_response.public_key) 2354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2355 plumbing_response.rate_limit) 2356 return resp 2357 2358 def get_rdpca_public_key(self, timeout=None): 2359 ''' 2360 GetRDPCAPublicKey retrieves the RDP CA public key. 2361 ''' 2362 deadline = None if timeout is None else time.time() + timeout 2363 req = ControlPanelGetRDPCAPublicKeyRequest() 2364 2365 tries = 0 2366 plumbing_response = None 2367 while True: 2368 t = None if deadline is None else deadline - time.time() 2369 try: 2370 plumbing_response = self.stub.GetRDPCAPublicKey( 2371 req, 2372 metadata=self.parent.get_metadata( 2373 'ControlPanel.GetRDPCAPublicKey', req), 2374 timeout=t) 2375 except Exception as e: 2376 if self.parent.shouldRetry(tries, e, deadline): 2377 tries += 1 2378 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2379 continue 2380 raise plumbing.convert_error_to_porcelain(e) from e 2381 break 2382 2383 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2384 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2385 plumbing_response.meta) 2386 resp.public_key = (plumbing_response.public_key) 2387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2388 plumbing_response.rate_limit) 2389 return resp 2390 2391 def verify_jwt(self, token, timeout=None): 2392 ''' 2393 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2394 ''' 2395 deadline = None if timeout is None else time.time() + timeout 2396 req = ControlPanelVerifyJWTRequest() 2397 2398 req.token = (token) 2399 tries = 0 2400 plumbing_response = None 2401 while True: 2402 t = None if deadline is None else deadline - time.time() 2403 try: 2404 plumbing_response = self.stub.VerifyJWT( 2405 req, 2406 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2407 req), 2408 timeout=t) 2409 except Exception as e: 2410 if self.parent.shouldRetry(tries, e, deadline): 2411 tries += 1 2412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2413 continue 2414 raise plumbing.convert_error_to_porcelain(e) from e 2415 break 2416 2417 resp = models.ControlPanelVerifyJWTResponse() 2418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2419 plumbing_response.meta) 2420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2421 plumbing_response.rate_limit) 2422 resp.valid = (plumbing_response.valid) 2423 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2325 def get_sshca_public_key(self, timeout=None): 2326 ''' 2327 GetSSHCAPublicKey retrieves the SSH CA public key. 2328 ''' 2329 deadline = None if timeout is None else time.time() + timeout 2330 req = ControlPanelGetSSHCAPublicKeyRequest() 2331 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.GetSSHCAPublicKey( 2338 req, 2339 metadata=self.parent.get_metadata( 2340 'ControlPanel.GetSSHCAPublicKey', req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2351 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2352 plumbing_response.meta) 2353 resp.public_key = (plumbing_response.public_key) 2354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2355 plumbing_response.rate_limit) 2356 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2358 def get_rdpca_public_key(self, timeout=None): 2359 ''' 2360 GetRDPCAPublicKey retrieves the RDP CA public key. 2361 ''' 2362 deadline = None if timeout is None else time.time() + timeout 2363 req = ControlPanelGetRDPCAPublicKeyRequest() 2364 2365 tries = 0 2366 plumbing_response = None 2367 while True: 2368 t = None if deadline is None else deadline - time.time() 2369 try: 2370 plumbing_response = self.stub.GetRDPCAPublicKey( 2371 req, 2372 metadata=self.parent.get_metadata( 2373 'ControlPanel.GetRDPCAPublicKey', req), 2374 timeout=t) 2375 except Exception as e: 2376 if self.parent.shouldRetry(tries, e, deadline): 2377 tries += 1 2378 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2379 continue 2380 raise plumbing.convert_error_to_porcelain(e) from e 2381 break 2382 2383 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2384 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2385 plumbing_response.meta) 2386 resp.public_key = (plumbing_response.public_key) 2387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2388 plumbing_response.rate_limit) 2389 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
verify_jwt(self, token, timeout=None)
2391 def verify_jwt(self, token, timeout=None): 2392 ''' 2393 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2394 ''' 2395 deadline = None if timeout is None else time.time() + timeout 2396 req = ControlPanelVerifyJWTRequest() 2397 2398 req.token = (token) 2399 tries = 0 2400 plumbing_response = None 2401 while True: 2402 t = None if deadline is None else deadline - time.time() 2403 try: 2404 plumbing_response = self.stub.VerifyJWT( 2405 req, 2406 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2407 req), 2408 timeout=t) 2409 except Exception as e: 2410 if self.parent.shouldRetry(tries, e, deadline): 2411 tries += 1 2412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2413 continue 2414 raise plumbing.convert_error_to_porcelain(e) from e 2415 break 2416 2417 resp = models.ControlPanelVerifyJWTResponse() 2418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2419 plumbing_response.meta) 2420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2421 plumbing_response.rate_limit) 2422 resp.valid = (plumbing_response.valid) 2423 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
Roles:
2426class Roles: 2427 ''' 2428 A Role has a list of access rules which determine which Resources the members 2429 of the Role have access to. An Account can be a member of multiple Roles via 2430 AccountAttachments. 2431 See `strongdm.models.Role`. 2432 ''' 2433 def __init__(self, channel, client): 2434 self.parent = client 2435 self.stub = RolesStub(channel) 2436 2437 def create(self, role, timeout=None): 2438 ''' 2439 Create registers a new Role. 2440 ''' 2441 deadline = None if timeout is None else time.time() + timeout 2442 req = RoleCreateRequest() 2443 2444 if role is not None: 2445 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2446 tries = 0 2447 plumbing_response = None 2448 while True: 2449 t = None if deadline is None else deadline - time.time() 2450 try: 2451 plumbing_response = self.stub.Create( 2452 req, 2453 metadata=self.parent.get_metadata('Roles.Create', req), 2454 timeout=t) 2455 except Exception as e: 2456 if self.parent.shouldRetry(tries, e, deadline): 2457 tries += 1 2458 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2459 continue 2460 raise plumbing.convert_error_to_porcelain(e) from e 2461 break 2462 2463 resp = models.RoleCreateResponse() 2464 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2465 plumbing_response.meta) 2466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2467 plumbing_response.rate_limit) 2468 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2469 return resp 2470 2471 def get(self, id, timeout=None): 2472 ''' 2473 Get reads one Role by ID. 2474 ''' 2475 deadline = None if timeout is None else time.time() + timeout 2476 req = RoleGetRequest() 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.CopyFrom(GetRequestMetadata()) 2479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2480 2481 req.id = (id) 2482 tries = 0 2483 plumbing_response = None 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = self.stub.Get( 2488 req, 2489 metadata=self.parent.get_metadata('Roles.Get', req), 2490 timeout=t) 2491 except Exception as e: 2492 if self.parent.shouldRetry(tries, e, deadline): 2493 tries += 1 2494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2495 continue 2496 raise plumbing.convert_error_to_porcelain(e) from e 2497 break 2498 2499 resp = models.RoleGetResponse() 2500 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2501 plumbing_response.meta) 2502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2503 plumbing_response.rate_limit) 2504 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2505 return resp 2506 2507 def update(self, role, timeout=None): 2508 ''' 2509 Update replaces all the fields of a Role by ID. 2510 ''' 2511 deadline = None if timeout is None else time.time() + timeout 2512 req = RoleUpdateRequest() 2513 2514 if role is not None: 2515 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2516 tries = 0 2517 plumbing_response = None 2518 while True: 2519 t = None if deadline is None else deadline - time.time() 2520 try: 2521 plumbing_response = self.stub.Update( 2522 req, 2523 metadata=self.parent.get_metadata('Roles.Update', req), 2524 timeout=t) 2525 except Exception as e: 2526 if self.parent.shouldRetry(tries, e, deadline): 2527 tries += 1 2528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2529 continue 2530 raise plumbing.convert_error_to_porcelain(e) from e 2531 break 2532 2533 resp = models.RoleUpdateResponse() 2534 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2535 plumbing_response.meta) 2536 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2537 plumbing_response.rate_limit) 2538 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2539 return resp 2540 2541 def delete(self, id, timeout=None): 2542 ''' 2543 Delete removes a Role by ID. 2544 ''' 2545 deadline = None if timeout is None else time.time() + timeout 2546 req = RoleDeleteRequest() 2547 2548 req.id = (id) 2549 tries = 0 2550 plumbing_response = None 2551 while True: 2552 t = None if deadline is None else deadline - time.time() 2553 try: 2554 plumbing_response = self.stub.Delete( 2555 req, 2556 metadata=self.parent.get_metadata('Roles.Delete', req), 2557 timeout=t) 2558 except Exception as e: 2559 if self.parent.shouldRetry(tries, e, deadline): 2560 tries += 1 2561 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2562 continue 2563 raise plumbing.convert_error_to_porcelain(e) from e 2564 break 2565 2566 resp = models.RoleDeleteResponse() 2567 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp 2572 2573 def list(self, filter, *args, timeout=None): 2574 ''' 2575 List gets a list of Roles matching a given set of criteria. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = RoleListRequest() 2579 req.meta.CopyFrom(ListRequestMetadata()) 2580 if self.parent.page_limit > 0: 2581 req.meta.limit = self.parent.page_limit 2582 if self.parent.snapshot_datetime is not None: 2583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2584 2585 req.filter = plumbing.quote_filter_args(filter, *args) 2586 2587 def generator(svc, req): 2588 tries = 0 2589 while True: 2590 t = None if deadline is None else deadline - time.time() 2591 try: 2592 plumbing_response = svc.stub.List( 2593 req, 2594 metadata=svc.parent.get_metadata('Roles.List', req), 2595 timeout=t) 2596 except Exception as e: 2597 if self.parent.shouldRetry(tries, e, deadline): 2598 tries += 1 2599 time.sleep( 2600 self.parent.exponentialBackoff(tries, deadline)) 2601 continue 2602 raise plumbing.convert_error_to_porcelain(e) from e 2603 tries = 0 2604 for plumbing_item in plumbing_response.roles: 2605 yield plumbing.convert_role_to_porcelain(plumbing_item) 2606 if plumbing_response.meta.next_cursor == '': 2607 break 2608 req.meta.cursor = plumbing_response.meta.next_cursor 2609 2610 return generator(self, req)
A Role has a list of access rules which determine which Resources the members
of the Role have access to. An Account can be a member of multiple Roles via
AccountAttachments.
See strongdm.models.Role.
def
create(self, role, timeout=None)
2437 def create(self, role, timeout=None): 2438 ''' 2439 Create registers a new Role. 2440 ''' 2441 deadline = None if timeout is None else time.time() + timeout 2442 req = RoleCreateRequest() 2443 2444 if role is not None: 2445 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2446 tries = 0 2447 plumbing_response = None 2448 while True: 2449 t = None if deadline is None else deadline - time.time() 2450 try: 2451 plumbing_response = self.stub.Create( 2452 req, 2453 metadata=self.parent.get_metadata('Roles.Create', req), 2454 timeout=t) 2455 except Exception as e: 2456 if self.parent.shouldRetry(tries, e, deadline): 2457 tries += 1 2458 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2459 continue 2460 raise plumbing.convert_error_to_porcelain(e) from e 2461 break 2462 2463 resp = models.RoleCreateResponse() 2464 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2465 plumbing_response.meta) 2466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2467 plumbing_response.rate_limit) 2468 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2469 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2471 def get(self, id, timeout=None): 2472 ''' 2473 Get reads one Role by ID. 2474 ''' 2475 deadline = None if timeout is None else time.time() + timeout 2476 req = RoleGetRequest() 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.CopyFrom(GetRequestMetadata()) 2479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2480 2481 req.id = (id) 2482 tries = 0 2483 plumbing_response = None 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = self.stub.Get( 2488 req, 2489 metadata=self.parent.get_metadata('Roles.Get', req), 2490 timeout=t) 2491 except Exception as e: 2492 if self.parent.shouldRetry(tries, e, deadline): 2493 tries += 1 2494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2495 continue 2496 raise plumbing.convert_error_to_porcelain(e) from e 2497 break 2498 2499 resp = models.RoleGetResponse() 2500 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2501 plumbing_response.meta) 2502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2503 plumbing_response.rate_limit) 2504 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2505 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2507 def update(self, role, timeout=None): 2508 ''' 2509 Update replaces all the fields of a Role by ID. 2510 ''' 2511 deadline = None if timeout is None else time.time() + timeout 2512 req = RoleUpdateRequest() 2513 2514 if role is not None: 2515 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2516 tries = 0 2517 plumbing_response = None 2518 while True: 2519 t = None if deadline is None else deadline - time.time() 2520 try: 2521 plumbing_response = self.stub.Update( 2522 req, 2523 metadata=self.parent.get_metadata('Roles.Update', req), 2524 timeout=t) 2525 except Exception as e: 2526 if self.parent.shouldRetry(tries, e, deadline): 2527 tries += 1 2528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2529 continue 2530 raise plumbing.convert_error_to_porcelain(e) from e 2531 break 2532 2533 resp = models.RoleUpdateResponse() 2534 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2535 plumbing_response.meta) 2536 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2537 plumbing_response.rate_limit) 2538 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2539 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
2541 def delete(self, id, timeout=None): 2542 ''' 2543 Delete removes a Role by ID. 2544 ''' 2545 deadline = None if timeout is None else time.time() + timeout 2546 req = RoleDeleteRequest() 2547 2548 req.id = (id) 2549 tries = 0 2550 plumbing_response = None 2551 while True: 2552 t = None if deadline is None else deadline - time.time() 2553 try: 2554 plumbing_response = self.stub.Delete( 2555 req, 2556 metadata=self.parent.get_metadata('Roles.Delete', req), 2557 timeout=t) 2558 except Exception as e: 2559 if self.parent.shouldRetry(tries, e, deadline): 2560 tries += 1 2561 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2562 continue 2563 raise plumbing.convert_error_to_porcelain(e) from e 2564 break 2565 2566 resp = models.RoleDeleteResponse() 2567 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
2573 def list(self, filter, *args, timeout=None): 2574 ''' 2575 List gets a list of Roles matching a given set of criteria. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = RoleListRequest() 2579 req.meta.CopyFrom(ListRequestMetadata()) 2580 if self.parent.page_limit > 0: 2581 req.meta.limit = self.parent.page_limit 2582 if self.parent.snapshot_datetime is not None: 2583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2584 2585 req.filter = plumbing.quote_filter_args(filter, *args) 2586 2587 def generator(svc, req): 2588 tries = 0 2589 while True: 2590 t = None if deadline is None else deadline - time.time() 2591 try: 2592 plumbing_response = svc.stub.List( 2593 req, 2594 metadata=svc.parent.get_metadata('Roles.List', req), 2595 timeout=t) 2596 except Exception as e: 2597 if self.parent.shouldRetry(tries, e, deadline): 2598 tries += 1 2599 time.sleep( 2600 self.parent.exponentialBackoff(tries, deadline)) 2601 continue 2602 raise plumbing.convert_error_to_porcelain(e) from e 2603 tries = 0 2604 for plumbing_item in plumbing_response.roles: 2605 yield plumbing.convert_role_to_porcelain(plumbing_item) 2606 if plumbing_response.meta.next_cursor == '': 2607 break 2608 req.meta.cursor = plumbing_response.meta.next_cursor 2609 2610 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
2613class SnapshotRoles: 2614 ''' 2615 SnapshotRoles exposes the read only methods of the Roles 2616 service for historical queries. 2617 ''' 2618 def __init__(self, roles): 2619 self.roles = roles 2620 2621 def get(self, id, timeout=None): 2622 ''' 2623 Get reads one Role by ID. 2624 ''' 2625 return self.roles.get(id, timeout=timeout) 2626 2627 def list(self, filter, *args, timeout=None): 2628 ''' 2629 List gets a list of Roles matching a given set of criteria. 2630 ''' 2631 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
2634class Groups: 2635 ''' 2636 A Group is a set of principals. 2637 See `strongdm.models.Group`. 2638 ''' 2639 def __init__(self, channel, client): 2640 self.parent = client 2641 self.stub = GroupsStub(channel) 2642 2643 def create(self, group, timeout=None): 2644 ''' 2645 Create registers a new Group. 2646 ''' 2647 deadline = None if timeout is None else time.time() + timeout 2648 req = GroupCreateRequest() 2649 2650 if group is not None: 2651 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2652 tries = 0 2653 plumbing_response = None 2654 while True: 2655 t = None if deadline is None else deadline - time.time() 2656 try: 2657 plumbing_response = self.stub.Create( 2658 req, 2659 metadata=self.parent.get_metadata('Groups.Create', req), 2660 timeout=t) 2661 except Exception as e: 2662 if self.parent.shouldRetry(tries, e, deadline): 2663 tries += 1 2664 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2665 continue 2666 raise plumbing.convert_error_to_porcelain(e) from e 2667 break 2668 2669 resp = models.GroupCreateResponse() 2670 resp.group = plumbing.convert_group_to_porcelain( 2671 plumbing_response.group) 2672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2673 plumbing_response.rate_limit) 2674 return resp 2675 2676 def create_from_roles(self, role_ids, commit, timeout=None): 2677 deadline = None if timeout is None else time.time() + timeout 2678 req = GroupCreateFromRolesRequest() 2679 2680 req.role_ids.extend((role_ids)) 2681 req.commit = (commit) 2682 tries = 0 2683 plumbing_response = None 2684 while True: 2685 t = None if deadline is None else deadline - time.time() 2686 try: 2687 plumbing_response = self.stub.CreateFromRoles( 2688 req, 2689 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2690 req), 2691 timeout=t) 2692 except Exception as e: 2693 if self.parent.shouldRetry(tries, e, deadline): 2694 tries += 1 2695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2696 continue 2697 raise plumbing.convert_error_to_porcelain(e) from e 2698 break 2699 2700 resp = models.GroupCreateFromRolesResponse() 2701 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2702 plumbing_response.group_from_role) 2703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2704 plumbing_response.rate_limit) 2705 return resp 2706 2707 def get(self, id, timeout=None): 2708 ''' 2709 Get reads one Group by ID. 2710 ''' 2711 deadline = None if timeout is None else time.time() + timeout 2712 req = GroupGetRequest() 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.CopyFrom(GetRequestMetadata()) 2715 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2716 2717 req.id = (id) 2718 tries = 0 2719 plumbing_response = None 2720 while True: 2721 t = None if deadline is None else deadline - time.time() 2722 try: 2723 plumbing_response = self.stub.Get( 2724 req, 2725 metadata=self.parent.get_metadata('Groups.Get', req), 2726 timeout=t) 2727 except Exception as e: 2728 if self.parent.shouldRetry(tries, e, deadline): 2729 tries += 1 2730 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2731 continue 2732 raise plumbing.convert_error_to_porcelain(e) from e 2733 break 2734 2735 resp = models.GroupGetResponse() 2736 resp.group = plumbing.convert_group_to_porcelain( 2737 plumbing_response.group) 2738 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2739 plumbing_response.meta) 2740 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2741 plumbing_response.rate_limit) 2742 return resp 2743 2744 def update(self, group, timeout=None): 2745 ''' 2746 Update replaces all the fields of a Group by ID. 2747 ''' 2748 deadline = None if timeout is None else time.time() + timeout 2749 req = GroupUpdateRequest() 2750 2751 if group is not None: 2752 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2753 tries = 0 2754 plumbing_response = None 2755 while True: 2756 t = None if deadline is None else deadline - time.time() 2757 try: 2758 plumbing_response = self.stub.Update( 2759 req, 2760 metadata=self.parent.get_metadata('Groups.Update', req), 2761 timeout=t) 2762 except Exception as e: 2763 if self.parent.shouldRetry(tries, e, deadline): 2764 tries += 1 2765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2766 continue 2767 raise plumbing.convert_error_to_porcelain(e) from e 2768 break 2769 2770 resp = models.GroupUpdateResponse() 2771 resp.group = plumbing.convert_group_to_porcelain( 2772 plumbing_response.group) 2773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2774 plumbing_response.rate_limit) 2775 return resp 2776 2777 def delete(self, id, timeout=None): 2778 ''' 2779 Delete removes a Group by ID. 2780 ''' 2781 deadline = None if timeout is None else time.time() + timeout 2782 req = GroupDeleteRequest() 2783 2784 req.id = (id) 2785 tries = 0 2786 plumbing_response = None 2787 while True: 2788 t = None if deadline is None else deadline - time.time() 2789 try: 2790 plumbing_response = self.stub.Delete( 2791 req, 2792 metadata=self.parent.get_metadata('Groups.Delete', req), 2793 timeout=t) 2794 except Exception as e: 2795 if self.parent.shouldRetry(tries, e, deadline): 2796 tries += 1 2797 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2798 continue 2799 raise plumbing.convert_error_to_porcelain(e) from e 2800 break 2801 2802 resp = models.GroupDeleteResponse() 2803 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2804 plumbing_response.meta) 2805 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2806 plumbing_response.rate_limit) 2807 return resp 2808 2809 def list(self, filter, *args, timeout=None): 2810 ''' 2811 List gets a list of Groups matching a given set of criteria. 2812 ''' 2813 deadline = None if timeout is None else time.time() + timeout 2814 req = GroupListRequest() 2815 req.meta.CopyFrom(ListRequestMetadata()) 2816 if self.parent.page_limit > 0: 2817 req.meta.limit = self.parent.page_limit 2818 if self.parent.snapshot_datetime is not None: 2819 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2820 2821 req.filter = plumbing.quote_filter_args(filter, *args) 2822 2823 def generator(svc, req): 2824 tries = 0 2825 while True: 2826 t = None if deadline is None else deadline - time.time() 2827 try: 2828 plumbing_response = svc.stub.List( 2829 req, 2830 metadata=svc.parent.get_metadata('Groups.List', req), 2831 timeout=t) 2832 except Exception as e: 2833 if self.parent.shouldRetry(tries, e, deadline): 2834 tries += 1 2835 time.sleep( 2836 self.parent.exponentialBackoff(tries, deadline)) 2837 continue 2838 raise plumbing.convert_error_to_porcelain(e) from e 2839 tries = 0 2840 for plumbing_item in plumbing_response.groups: 2841 yield plumbing.convert_group_to_porcelain(plumbing_item) 2842 if plumbing_response.meta.next_cursor == '': 2843 break 2844 req.meta.cursor = plumbing_response.meta.next_cursor 2845 2846 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
2643 def create(self, group, timeout=None): 2644 ''' 2645 Create registers a new Group. 2646 ''' 2647 deadline = None if timeout is None else time.time() + timeout 2648 req = GroupCreateRequest() 2649 2650 if group is not None: 2651 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2652 tries = 0 2653 plumbing_response = None 2654 while True: 2655 t = None if deadline is None else deadline - time.time() 2656 try: 2657 plumbing_response = self.stub.Create( 2658 req, 2659 metadata=self.parent.get_metadata('Groups.Create', req), 2660 timeout=t) 2661 except Exception as e: 2662 if self.parent.shouldRetry(tries, e, deadline): 2663 tries += 1 2664 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2665 continue 2666 raise plumbing.convert_error_to_porcelain(e) from e 2667 break 2668 2669 resp = models.GroupCreateResponse() 2670 resp.group = plumbing.convert_group_to_porcelain( 2671 plumbing_response.group) 2672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2673 plumbing_response.rate_limit) 2674 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
2676 def create_from_roles(self, role_ids, commit, timeout=None): 2677 deadline = None if timeout is None else time.time() + timeout 2678 req = GroupCreateFromRolesRequest() 2679 2680 req.role_ids.extend((role_ids)) 2681 req.commit = (commit) 2682 tries = 0 2683 plumbing_response = None 2684 while True: 2685 t = None if deadline is None else deadline - time.time() 2686 try: 2687 plumbing_response = self.stub.CreateFromRoles( 2688 req, 2689 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2690 req), 2691 timeout=t) 2692 except Exception as e: 2693 if self.parent.shouldRetry(tries, e, deadline): 2694 tries += 1 2695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2696 continue 2697 raise plumbing.convert_error_to_porcelain(e) from e 2698 break 2699 2700 resp = models.GroupCreateFromRolesResponse() 2701 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2702 plumbing_response.group_from_role) 2703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2704 plumbing_response.rate_limit) 2705 return resp
def
get(self, id, timeout=None)
2707 def get(self, id, timeout=None): 2708 ''' 2709 Get reads one Group by ID. 2710 ''' 2711 deadline = None if timeout is None else time.time() + timeout 2712 req = GroupGetRequest() 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.CopyFrom(GetRequestMetadata()) 2715 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2716 2717 req.id = (id) 2718 tries = 0 2719 plumbing_response = None 2720 while True: 2721 t = None if deadline is None else deadline - time.time() 2722 try: 2723 plumbing_response = self.stub.Get( 2724 req, 2725 metadata=self.parent.get_metadata('Groups.Get', req), 2726 timeout=t) 2727 except Exception as e: 2728 if self.parent.shouldRetry(tries, e, deadline): 2729 tries += 1 2730 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2731 continue 2732 raise plumbing.convert_error_to_porcelain(e) from e 2733 break 2734 2735 resp = models.GroupGetResponse() 2736 resp.group = plumbing.convert_group_to_porcelain( 2737 plumbing_response.group) 2738 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2739 plumbing_response.meta) 2740 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2741 plumbing_response.rate_limit) 2742 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
2744 def update(self, group, timeout=None): 2745 ''' 2746 Update replaces all the fields of a Group by ID. 2747 ''' 2748 deadline = None if timeout is None else time.time() + timeout 2749 req = GroupUpdateRequest() 2750 2751 if group is not None: 2752 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2753 tries = 0 2754 plumbing_response = None 2755 while True: 2756 t = None if deadline is None else deadline - time.time() 2757 try: 2758 plumbing_response = self.stub.Update( 2759 req, 2760 metadata=self.parent.get_metadata('Groups.Update', req), 2761 timeout=t) 2762 except Exception as e: 2763 if self.parent.shouldRetry(tries, e, deadline): 2764 tries += 1 2765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2766 continue 2767 raise plumbing.convert_error_to_porcelain(e) from e 2768 break 2769 2770 resp = models.GroupUpdateResponse() 2771 resp.group = plumbing.convert_group_to_porcelain( 2772 plumbing_response.group) 2773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2774 plumbing_response.rate_limit) 2775 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
2777 def delete(self, id, timeout=None): 2778 ''' 2779 Delete removes a Group by ID. 2780 ''' 2781 deadline = None if timeout is None else time.time() + timeout 2782 req = GroupDeleteRequest() 2783 2784 req.id = (id) 2785 tries = 0 2786 plumbing_response = None 2787 while True: 2788 t = None if deadline is None else deadline - time.time() 2789 try: 2790 plumbing_response = self.stub.Delete( 2791 req, 2792 metadata=self.parent.get_metadata('Groups.Delete', req), 2793 timeout=t) 2794 except Exception as e: 2795 if self.parent.shouldRetry(tries, e, deadline): 2796 tries += 1 2797 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2798 continue 2799 raise plumbing.convert_error_to_porcelain(e) from e 2800 break 2801 2802 resp = models.GroupDeleteResponse() 2803 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2804 plumbing_response.meta) 2805 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2806 plumbing_response.rate_limit) 2807 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
2809 def list(self, filter, *args, timeout=None): 2810 ''' 2811 List gets a list of Groups matching a given set of criteria. 2812 ''' 2813 deadline = None if timeout is None else time.time() + timeout 2814 req = GroupListRequest() 2815 req.meta.CopyFrom(ListRequestMetadata()) 2816 if self.parent.page_limit > 0: 2817 req.meta.limit = self.parent.page_limit 2818 if self.parent.snapshot_datetime is not None: 2819 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2820 2821 req.filter = plumbing.quote_filter_args(filter, *args) 2822 2823 def generator(svc, req): 2824 tries = 0 2825 while True: 2826 t = None if deadline is None else deadline - time.time() 2827 try: 2828 plumbing_response = svc.stub.List( 2829 req, 2830 metadata=svc.parent.get_metadata('Groups.List', req), 2831 timeout=t) 2832 except Exception as e: 2833 if self.parent.shouldRetry(tries, e, deadline): 2834 tries += 1 2835 time.sleep( 2836 self.parent.exponentialBackoff(tries, deadline)) 2837 continue 2838 raise plumbing.convert_error_to_porcelain(e) from e 2839 tries = 0 2840 for plumbing_item in plumbing_response.groups: 2841 yield plumbing.convert_group_to_porcelain(plumbing_item) 2842 if plumbing_response.meta.next_cursor == '': 2843 break 2844 req.meta.cursor = plumbing_response.meta.next_cursor 2845 2846 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
2849class SnapshotGroups: 2850 ''' 2851 SnapshotGroups exposes the read only methods of the Groups 2852 service for historical queries. 2853 ''' 2854 def __init__(self, groups): 2855 self.groups = groups 2856 2857 def get(self, id, timeout=None): 2858 ''' 2859 Get reads one Group by ID. 2860 ''' 2861 return self.groups.get(id, timeout=timeout) 2862 2863 def list(self, filter, *args, timeout=None): 2864 ''' 2865 List gets a list of Groups matching a given set of criteria. 2866 ''' 2867 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
2870class GroupsHistory: 2871 ''' 2872 GroupsHistory records all changes to the state of a Group. 2873 See `strongdm.models.GroupHistory`. 2874 ''' 2875 def __init__(self, channel, client): 2876 self.parent = client 2877 self.stub = GroupsHistoryStub(channel) 2878 2879 def list(self, filter, *args, timeout=None): 2880 ''' 2881 List gets a list of GroupHistory records matching a given set of criteria. 2882 ''' 2883 deadline = None if timeout is None else time.time() + timeout 2884 req = GroupHistoryListRequest() 2885 req.meta.CopyFrom(ListRequestMetadata()) 2886 if self.parent.page_limit > 0: 2887 req.meta.limit = self.parent.page_limit 2888 if self.parent.snapshot_datetime is not None: 2889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2890 2891 req.filter = plumbing.quote_filter_args(filter, *args) 2892 2893 def generator(svc, req): 2894 tries = 0 2895 while True: 2896 t = None if deadline is None else deadline - time.time() 2897 try: 2898 plumbing_response = svc.stub.List( 2899 req, 2900 metadata=svc.parent.get_metadata( 2901 'GroupsHistory.List', req), 2902 timeout=t) 2903 except Exception as e: 2904 if self.parent.shouldRetry(tries, e, deadline): 2905 tries += 1 2906 time.sleep( 2907 self.parent.exponentialBackoff(tries, deadline)) 2908 continue 2909 raise plumbing.convert_error_to_porcelain(e) from e 2910 tries = 0 2911 for plumbing_item in plumbing_response.history: 2912 yield plumbing.convert_group_history_to_porcelain( 2913 plumbing_item) 2914 if plumbing_response.meta.next_cursor == '': 2915 break 2916 req.meta.cursor = plumbing_response.meta.next_cursor 2917 2918 return generator(self, req)
GroupsHistory records all changes to the state of a Group.
See strongdm.models.GroupHistory.
def
list(self, filter, *args, timeout=None)
2879 def list(self, filter, *args, timeout=None): 2880 ''' 2881 List gets a list of GroupHistory records matching a given set of criteria. 2882 ''' 2883 deadline = None if timeout is None else time.time() + timeout 2884 req = GroupHistoryListRequest() 2885 req.meta.CopyFrom(ListRequestMetadata()) 2886 if self.parent.page_limit > 0: 2887 req.meta.limit = self.parent.page_limit 2888 if self.parent.snapshot_datetime is not None: 2889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2890 2891 req.filter = plumbing.quote_filter_args(filter, *args) 2892 2893 def generator(svc, req): 2894 tries = 0 2895 while True: 2896 t = None if deadline is None else deadline - time.time() 2897 try: 2898 plumbing_response = svc.stub.List( 2899 req, 2900 metadata=svc.parent.get_metadata( 2901 'GroupsHistory.List', req), 2902 timeout=t) 2903 except Exception as e: 2904 if self.parent.shouldRetry(tries, e, deadline): 2905 tries += 1 2906 time.sleep( 2907 self.parent.exponentialBackoff(tries, deadline)) 2908 continue 2909 raise plumbing.convert_error_to_porcelain(e) from e 2910 tries = 0 2911 for plumbing_item in plumbing_response.history: 2912 yield plumbing.convert_group_history_to_porcelain( 2913 plumbing_item) 2914 if plumbing_response.meta.next_cursor == '': 2915 break 2916 req.meta.cursor = plumbing_response.meta.next_cursor 2917 2918 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
2921class GroupsRoles: 2922 ''' 2923 A GroupRole is an assignment of a Group to a Role. 2924 See `strongdm.models.GroupRole`. 2925 ''' 2926 def __init__(self, channel, client): 2927 self.parent = client 2928 self.stub = GroupsRolesStub(channel) 2929 2930 def create(self, group_role, timeout=None): 2931 ''' 2932 Create registers a new GroupRole. 2933 ''' 2934 deadline = None if timeout is None else time.time() + timeout 2935 req = GroupRoleCreateRequest() 2936 2937 if group_role is not None: 2938 req.group_role.CopyFrom( 2939 plumbing.convert_group_role_to_plumbing(group_role)) 2940 tries = 0 2941 plumbing_response = None 2942 while True: 2943 t = None if deadline is None else deadline - time.time() 2944 try: 2945 plumbing_response = self.stub.Create( 2946 req, 2947 metadata=self.parent.get_metadata('GroupsRoles.Create', 2948 req), 2949 timeout=t) 2950 except Exception as e: 2951 if self.parent.shouldRetry(tries, e, deadline): 2952 tries += 1 2953 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2954 continue 2955 raise plumbing.convert_error_to_porcelain(e) from e 2956 break 2957 2958 resp = models.GroupRoleCreateResponse() 2959 resp.group_role = plumbing.convert_group_role_to_porcelain( 2960 plumbing_response.group_role) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp 2964 2965 def get(self, id, timeout=None): 2966 ''' 2967 Get reads one GroupRole by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupRoleGetRequest() 2971 if self.parent.snapshot_datetime is not None: 2972 req.meta.CopyFrom(GetRequestMetadata()) 2973 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2974 2975 req.id = (id) 2976 tries = 0 2977 plumbing_response = None 2978 while True: 2979 t = None if deadline is None else deadline - time.time() 2980 try: 2981 plumbing_response = self.stub.Get( 2982 req, 2983 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2984 timeout=t) 2985 except Exception as e: 2986 if self.parent.shouldRetry(tries, e, deadline): 2987 tries += 1 2988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2989 continue 2990 raise plumbing.convert_error_to_porcelain(e) from e 2991 break 2992 2993 resp = models.GroupRoleGetResponse() 2994 resp.group_role = plumbing.convert_group_role_to_porcelain( 2995 plumbing_response.group_role) 2996 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2997 plumbing_response.meta) 2998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2999 plumbing_response.rate_limit) 3000 return resp 3001 3002 def delete(self, id, timeout=None): 3003 ''' 3004 Delete removes a GroupRole by ID. 3005 ''' 3006 deadline = None if timeout is None else time.time() + timeout 3007 req = GroupRoleDeleteRequest() 3008 3009 req.id = (id) 3010 tries = 0 3011 plumbing_response = None 3012 while True: 3013 t = None if deadline is None else deadline - time.time() 3014 try: 3015 plumbing_response = self.stub.Delete( 3016 req, 3017 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3018 req), 3019 timeout=t) 3020 except Exception as e: 3021 if self.parent.shouldRetry(tries, e, deadline): 3022 tries += 1 3023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3024 continue 3025 raise plumbing.convert_error_to_porcelain(e) from e 3026 break 3027 3028 resp = models.GroupRoleDeleteResponse() 3029 resp.group_role = plumbing.convert_group_role_to_porcelain( 3030 plumbing_response.group_role) 3031 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3032 plumbing_response.meta) 3033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3034 plumbing_response.rate_limit) 3035 return resp 3036 3037 def list(self, filter, *args, timeout=None): 3038 ''' 3039 List gets a list of GroupRoles matching a given set of criteria. 3040 ''' 3041 deadline = None if timeout is None else time.time() + timeout 3042 req = GroupRoleListRequest() 3043 req.meta.CopyFrom(ListRequestMetadata()) 3044 if self.parent.page_limit > 0: 3045 req.meta.limit = self.parent.page_limit 3046 if self.parent.snapshot_datetime is not None: 3047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3048 3049 req.filter = plumbing.quote_filter_args(filter, *args) 3050 3051 def generator(svc, req): 3052 tries = 0 3053 while True: 3054 t = None if deadline is None else deadline - time.time() 3055 try: 3056 plumbing_response = svc.stub.List( 3057 req, 3058 metadata=svc.parent.get_metadata( 3059 'GroupsRoles.List', req), 3060 timeout=t) 3061 except Exception as e: 3062 if self.parent.shouldRetry(tries, e, deadline): 3063 tries += 1 3064 time.sleep( 3065 self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 tries = 0 3069 for plumbing_item in plumbing_response.groups_roles: 3070 yield plumbing.convert_group_role_to_porcelain( 3071 plumbing_item) 3072 if plumbing_response.meta.next_cursor == '': 3073 break 3074 req.meta.cursor = plumbing_response.meta.next_cursor 3075 3076 return generator(self, req)
A GroupRole is an assignment of a Group to a Role.
See strongdm.models.GroupRole.
def
create(self, group_role, timeout=None)
2930 def create(self, group_role, timeout=None): 2931 ''' 2932 Create registers a new GroupRole. 2933 ''' 2934 deadline = None if timeout is None else time.time() + timeout 2935 req = GroupRoleCreateRequest() 2936 2937 if group_role is not None: 2938 req.group_role.CopyFrom( 2939 plumbing.convert_group_role_to_plumbing(group_role)) 2940 tries = 0 2941 plumbing_response = None 2942 while True: 2943 t = None if deadline is None else deadline - time.time() 2944 try: 2945 plumbing_response = self.stub.Create( 2946 req, 2947 metadata=self.parent.get_metadata('GroupsRoles.Create', 2948 req), 2949 timeout=t) 2950 except Exception as e: 2951 if self.parent.shouldRetry(tries, e, deadline): 2952 tries += 1 2953 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2954 continue 2955 raise plumbing.convert_error_to_porcelain(e) from e 2956 break 2957 2958 resp = models.GroupRoleCreateResponse() 2959 resp.group_role = plumbing.convert_group_role_to_porcelain( 2960 plumbing_response.group_role) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
2965 def get(self, id, timeout=None): 2966 ''' 2967 Get reads one GroupRole by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupRoleGetRequest() 2971 if self.parent.snapshot_datetime is not None: 2972 req.meta.CopyFrom(GetRequestMetadata()) 2973 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2974 2975 req.id = (id) 2976 tries = 0 2977 plumbing_response = None 2978 while True: 2979 t = None if deadline is None else deadline - time.time() 2980 try: 2981 plumbing_response = self.stub.Get( 2982 req, 2983 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2984 timeout=t) 2985 except Exception as e: 2986 if self.parent.shouldRetry(tries, e, deadline): 2987 tries += 1 2988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2989 continue 2990 raise plumbing.convert_error_to_porcelain(e) from e 2991 break 2992 2993 resp = models.GroupRoleGetResponse() 2994 resp.group_role = plumbing.convert_group_role_to_porcelain( 2995 plumbing_response.group_role) 2996 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2997 plumbing_response.meta) 2998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2999 plumbing_response.rate_limit) 3000 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3002 def delete(self, id, timeout=None): 3003 ''' 3004 Delete removes a GroupRole by ID. 3005 ''' 3006 deadline = None if timeout is None else time.time() + timeout 3007 req = GroupRoleDeleteRequest() 3008 3009 req.id = (id) 3010 tries = 0 3011 plumbing_response = None 3012 while True: 3013 t = None if deadline is None else deadline - time.time() 3014 try: 3015 plumbing_response = self.stub.Delete( 3016 req, 3017 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3018 req), 3019 timeout=t) 3020 except Exception as e: 3021 if self.parent.shouldRetry(tries, e, deadline): 3022 tries += 1 3023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3024 continue 3025 raise plumbing.convert_error_to_porcelain(e) from e 3026 break 3027 3028 resp = models.GroupRoleDeleteResponse() 3029 resp.group_role = plumbing.convert_group_role_to_porcelain( 3030 plumbing_response.group_role) 3031 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3032 plumbing_response.meta) 3033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3034 plumbing_response.rate_limit) 3035 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3037 def list(self, filter, *args, timeout=None): 3038 ''' 3039 List gets a list of GroupRoles matching a given set of criteria. 3040 ''' 3041 deadline = None if timeout is None else time.time() + timeout 3042 req = GroupRoleListRequest() 3043 req.meta.CopyFrom(ListRequestMetadata()) 3044 if self.parent.page_limit > 0: 3045 req.meta.limit = self.parent.page_limit 3046 if self.parent.snapshot_datetime is not None: 3047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3048 3049 req.filter = plumbing.quote_filter_args(filter, *args) 3050 3051 def generator(svc, req): 3052 tries = 0 3053 while True: 3054 t = None if deadline is None else deadline - time.time() 3055 try: 3056 plumbing_response = svc.stub.List( 3057 req, 3058 metadata=svc.parent.get_metadata( 3059 'GroupsRoles.List', req), 3060 timeout=t) 3061 except Exception as e: 3062 if self.parent.shouldRetry(tries, e, deadline): 3063 tries += 1 3064 time.sleep( 3065 self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 tries = 0 3069 for plumbing_item in plumbing_response.groups_roles: 3070 yield plumbing.convert_group_role_to_porcelain( 3071 plumbing_item) 3072 if plumbing_response.meta.next_cursor == '': 3073 break 3074 req.meta.cursor = plumbing_response.meta.next_cursor 3075 3076 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3079class SnapshotGroupsRoles: 3080 ''' 3081 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3082 service for historical queries. 3083 ''' 3084 def __init__(self, groups_roles): 3085 self.groups_roles = groups_roles 3086 3087 def get(self, id, timeout=None): 3088 ''' 3089 Get reads one GroupRole by ID. 3090 ''' 3091 return self.groups_roles.get(id, timeout=timeout) 3092 3093 def list(self, filter, *args, timeout=None): 3094 ''' 3095 List gets a list of GroupRoles matching a given set of criteria. 3096 ''' 3097 return self.groups_roles.list(filter, *args, timeout=timeout)
SnapshotGroupsRoles exposes the read only methods of the GroupsRoles service for historical queries.
def
get(self, id, timeout=None)
3087 def get(self, id, timeout=None): 3088 ''' 3089 Get reads one GroupRole by ID. 3090 ''' 3091 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3093 def list(self, filter, *args, timeout=None): 3094 ''' 3095 List gets a list of GroupRoles matching a given set of criteria. 3096 ''' 3097 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3100class GroupsRolesHistory: 3101 ''' 3102 GroupsRolesHistory records all changes to the state of a GroupRole. 3103 See `strongdm.models.GroupRoleHistory`. 3104 ''' 3105 def __init__(self, channel, client): 3106 self.parent = client 3107 self.stub = GroupsRolesHistoryStub(channel) 3108 3109 def list(self, filter, *args, timeout=None): 3110 ''' 3111 List gets a list of GroupRoleHistory records matching a given set of criteria. 3112 ''' 3113 deadline = None if timeout is None else time.time() + timeout 3114 req = GroupRoleHistoryListRequest() 3115 req.meta.CopyFrom(ListRequestMetadata()) 3116 if self.parent.page_limit > 0: 3117 req.meta.limit = self.parent.page_limit 3118 if self.parent.snapshot_datetime is not None: 3119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3120 3121 req.filter = plumbing.quote_filter_args(filter, *args) 3122 3123 def generator(svc, req): 3124 tries = 0 3125 while True: 3126 t = None if deadline is None else deadline - time.time() 3127 try: 3128 plumbing_response = svc.stub.List( 3129 req, 3130 metadata=svc.parent.get_metadata( 3131 'GroupsRolesHistory.List', req), 3132 timeout=t) 3133 except Exception as e: 3134 if self.parent.shouldRetry(tries, e, deadline): 3135 tries += 1 3136 time.sleep( 3137 self.parent.exponentialBackoff(tries, deadline)) 3138 continue 3139 raise plumbing.convert_error_to_porcelain(e) from e 3140 tries = 0 3141 for plumbing_item in plumbing_response.history: 3142 yield plumbing.convert_group_role_history_to_porcelain( 3143 plumbing_item) 3144 if plumbing_response.meta.next_cursor == '': 3145 break 3146 req.meta.cursor = plumbing_response.meta.next_cursor 3147 3148 return generator(self, req)
GroupsRolesHistory records all changes to the state of a GroupRole.
See strongdm.models.GroupRoleHistory.
def
list(self, filter, *args, timeout=None)
3109 def list(self, filter, *args, timeout=None): 3110 ''' 3111 List gets a list of GroupRoleHistory records matching a given set of criteria. 3112 ''' 3113 deadline = None if timeout is None else time.time() + timeout 3114 req = GroupRoleHistoryListRequest() 3115 req.meta.CopyFrom(ListRequestMetadata()) 3116 if self.parent.page_limit > 0: 3117 req.meta.limit = self.parent.page_limit 3118 if self.parent.snapshot_datetime is not None: 3119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3120 3121 req.filter = plumbing.quote_filter_args(filter, *args) 3122 3123 def generator(svc, req): 3124 tries = 0 3125 while True: 3126 t = None if deadline is None else deadline - time.time() 3127 try: 3128 plumbing_response = svc.stub.List( 3129 req, 3130 metadata=svc.parent.get_metadata( 3131 'GroupsRolesHistory.List', req), 3132 timeout=t) 3133 except Exception as e: 3134 if self.parent.shouldRetry(tries, e, deadline): 3135 tries += 1 3136 time.sleep( 3137 self.parent.exponentialBackoff(tries, deadline)) 3138 continue 3139 raise plumbing.convert_error_to_porcelain(e) from e 3140 tries = 0 3141 for plumbing_item in plumbing_response.history: 3142 yield plumbing.convert_group_role_history_to_porcelain( 3143 plumbing_item) 3144 if plumbing_response.meta.next_cursor == '': 3145 break 3146 req.meta.cursor = plumbing_response.meta.next_cursor 3147 3148 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3151class HealthChecks: 3152 ''' 3153 HealthChecks lists the last healthcheck between each node and resource. 3154 Note the unconventional capitalization here is to prevent having a collision with GRPC 3155 See `strongdm.models.Healthcheck`. 3156 ''' 3157 def __init__(self, channel, client): 3158 self.parent = client 3159 self.stub = HealthChecksStub(channel) 3160 3161 def list(self, filter, *args, timeout=None): 3162 ''' 3163 List gets a list of Healthchecks matching a given set of criteria. 3164 ''' 3165 deadline = None if timeout is None else time.time() + timeout 3166 req = HealthcheckListRequest() 3167 req.meta.CopyFrom(ListRequestMetadata()) 3168 if self.parent.page_limit > 0: 3169 req.meta.limit = self.parent.page_limit 3170 if self.parent.snapshot_datetime is not None: 3171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3172 3173 req.filter = plumbing.quote_filter_args(filter, *args) 3174 3175 def generator(svc, req): 3176 tries = 0 3177 while True: 3178 t = None if deadline is None else deadline - time.time() 3179 try: 3180 plumbing_response = svc.stub.List( 3181 req, 3182 metadata=svc.parent.get_metadata( 3183 'HealthChecks.List', req), 3184 timeout=t) 3185 except Exception as e: 3186 if self.parent.shouldRetry(tries, e, deadline): 3187 tries += 1 3188 time.sleep( 3189 self.parent.exponentialBackoff(tries, deadline)) 3190 continue 3191 raise plumbing.convert_error_to_porcelain(e) from e 3192 tries = 0 3193 for plumbing_item in plumbing_response.healthchecks: 3194 yield plumbing.convert_healthcheck_to_porcelain( 3195 plumbing_item) 3196 if plumbing_response.meta.next_cursor == '': 3197 break 3198 req.meta.cursor = plumbing_response.meta.next_cursor 3199 3200 return generator(self, req)
HealthChecks lists the last healthcheck between each node and resource.
Note the unconventional capitalization here is to prevent having a collision with GRPC
See strongdm.models.Healthcheck.
def
list(self, filter, *args, timeout=None)
3161 def list(self, filter, *args, timeout=None): 3162 ''' 3163 List gets a list of Healthchecks matching a given set of criteria. 3164 ''' 3165 deadline = None if timeout is None else time.time() + timeout 3166 req = HealthcheckListRequest() 3167 req.meta.CopyFrom(ListRequestMetadata()) 3168 if self.parent.page_limit > 0: 3169 req.meta.limit = self.parent.page_limit 3170 if self.parent.snapshot_datetime is not None: 3171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3172 3173 req.filter = plumbing.quote_filter_args(filter, *args) 3174 3175 def generator(svc, req): 3176 tries = 0 3177 while True: 3178 t = None if deadline is None else deadline - time.time() 3179 try: 3180 plumbing_response = svc.stub.List( 3181 req, 3182 metadata=svc.parent.get_metadata( 3183 'HealthChecks.List', req), 3184 timeout=t) 3185 except Exception as e: 3186 if self.parent.shouldRetry(tries, e, deadline): 3187 tries += 1 3188 time.sleep( 3189 self.parent.exponentialBackoff(tries, deadline)) 3190 continue 3191 raise plumbing.convert_error_to_porcelain(e) from e 3192 tries = 0 3193 for plumbing_item in plumbing_response.healthchecks: 3194 yield plumbing.convert_healthcheck_to_porcelain( 3195 plumbing_item) 3196 if plumbing_response.meta.next_cursor == '': 3197 break 3198 req.meta.cursor = plumbing_response.meta.next_cursor 3199 3200 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3203class IdentityAliases: 3204 ''' 3205 IdentityAliases assign an alias to an account within an IdentitySet. 3206 The alias is used as the username when connecting to a identity supported resource. 3207 See `strongdm.models.IdentityAlias`. 3208 ''' 3209 def __init__(self, channel, client): 3210 self.parent = client 3211 self.stub = IdentityAliasesStub(channel) 3212 3213 def create(self, identity_alias, timeout=None): 3214 ''' 3215 Create registers a new IdentityAlias. 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = IdentityAliasCreateRequest() 3219 3220 if identity_alias is not None: 3221 req.identity_alias.CopyFrom( 3222 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3223 tries = 0 3224 plumbing_response = None 3225 while True: 3226 t = None if deadline is None else deadline - time.time() 3227 try: 3228 plumbing_response = self.stub.Create( 3229 req, 3230 metadata=self.parent.get_metadata('IdentityAliases.Create', 3231 req), 3232 timeout=t) 3233 except Exception as e: 3234 if self.parent.shouldRetry(tries, e, deadline): 3235 tries += 1 3236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3237 continue 3238 raise plumbing.convert_error_to_porcelain(e) from e 3239 break 3240 3241 resp = models.IdentityAliasCreateResponse() 3242 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3243 plumbing_response.identity_alias) 3244 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3245 plumbing_response.meta) 3246 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3247 plumbing_response.rate_limit) 3248 return resp 3249 3250 def get(self, id, timeout=None): 3251 ''' 3252 Get reads one IdentityAlias by ID. 3253 ''' 3254 deadline = None if timeout is None else time.time() + timeout 3255 req = IdentityAliasGetRequest() 3256 if self.parent.snapshot_datetime is not None: 3257 req.meta.CopyFrom(GetRequestMetadata()) 3258 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3259 3260 req.id = (id) 3261 tries = 0 3262 plumbing_response = None 3263 while True: 3264 t = None if deadline is None else deadline - time.time() 3265 try: 3266 plumbing_response = self.stub.Get( 3267 req, 3268 metadata=self.parent.get_metadata('IdentityAliases.Get', 3269 req), 3270 timeout=t) 3271 except Exception as e: 3272 if self.parent.shouldRetry(tries, e, deadline): 3273 tries += 1 3274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3275 continue 3276 raise plumbing.convert_error_to_porcelain(e) from e 3277 break 3278 3279 resp = models.IdentityAliasGetResponse() 3280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3281 plumbing_response.identity_alias) 3282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3283 plumbing_response.meta) 3284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3285 plumbing_response.rate_limit) 3286 return resp 3287 3288 def update(self, identity_alias, timeout=None): 3289 ''' 3290 Update replaces all the fields of a IdentityAlias by ID. 3291 ''' 3292 deadline = None if timeout is None else time.time() + timeout 3293 req = IdentityAliasUpdateRequest() 3294 3295 if identity_alias is not None: 3296 req.identity_alias.CopyFrom( 3297 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3298 tries = 0 3299 plumbing_response = None 3300 while True: 3301 t = None if deadline is None else deadline - time.time() 3302 try: 3303 plumbing_response = self.stub.Update( 3304 req, 3305 metadata=self.parent.get_metadata('IdentityAliases.Update', 3306 req), 3307 timeout=t) 3308 except Exception as e: 3309 if self.parent.shouldRetry(tries, e, deadline): 3310 tries += 1 3311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3312 continue 3313 raise plumbing.convert_error_to_porcelain(e) from e 3314 break 3315 3316 resp = models.IdentityAliasUpdateResponse() 3317 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3318 plumbing_response.identity_alias) 3319 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3320 plumbing_response.meta) 3321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3322 plumbing_response.rate_limit) 3323 return resp 3324 3325 def delete(self, id, timeout=None): 3326 ''' 3327 Delete removes a IdentityAlias by ID. 3328 ''' 3329 deadline = None if timeout is None else time.time() + timeout 3330 req = IdentityAliasDeleteRequest() 3331 3332 req.id = (id) 3333 tries = 0 3334 plumbing_response = None 3335 while True: 3336 t = None if deadline is None else deadline - time.time() 3337 try: 3338 plumbing_response = self.stub.Delete( 3339 req, 3340 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3341 req), 3342 timeout=t) 3343 except Exception as e: 3344 if self.parent.shouldRetry(tries, e, deadline): 3345 tries += 1 3346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3347 continue 3348 raise plumbing.convert_error_to_porcelain(e) from e 3349 break 3350 3351 resp = models.IdentityAliasDeleteResponse() 3352 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3353 plumbing_response.meta) 3354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3355 plumbing_response.rate_limit) 3356 return resp 3357 3358 def list(self, filter, *args, timeout=None): 3359 ''' 3360 List gets a list of IdentityAliases matching a given set of criteria. 3361 ''' 3362 deadline = None if timeout is None else time.time() + timeout 3363 req = IdentityAliasListRequest() 3364 req.meta.CopyFrom(ListRequestMetadata()) 3365 if self.parent.page_limit > 0: 3366 req.meta.limit = self.parent.page_limit 3367 if self.parent.snapshot_datetime is not None: 3368 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3369 3370 req.filter = plumbing.quote_filter_args(filter, *args) 3371 3372 def generator(svc, req): 3373 tries = 0 3374 while True: 3375 t = None if deadline is None else deadline - time.time() 3376 try: 3377 plumbing_response = svc.stub.List( 3378 req, 3379 metadata=svc.parent.get_metadata( 3380 'IdentityAliases.List', req), 3381 timeout=t) 3382 except Exception as e: 3383 if self.parent.shouldRetry(tries, e, deadline): 3384 tries += 1 3385 time.sleep( 3386 self.parent.exponentialBackoff(tries, deadline)) 3387 continue 3388 raise plumbing.convert_error_to_porcelain(e) from e 3389 tries = 0 3390 for plumbing_item in plumbing_response.identity_aliases: 3391 yield plumbing.convert_identity_alias_to_porcelain( 3392 plumbing_item) 3393 if plumbing_response.meta.next_cursor == '': 3394 break 3395 req.meta.cursor = plumbing_response.meta.next_cursor 3396 3397 return generator(self, req)
IdentityAliases assign an alias to an account within an IdentitySet.
The alias is used as the username when connecting to a identity supported resource.
See strongdm.models.IdentityAlias.
def
create(self, identity_alias, timeout=None)
3213 def create(self, identity_alias, timeout=None): 3214 ''' 3215 Create registers a new IdentityAlias. 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = IdentityAliasCreateRequest() 3219 3220 if identity_alias is not None: 3221 req.identity_alias.CopyFrom( 3222 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3223 tries = 0 3224 plumbing_response = None 3225 while True: 3226 t = None if deadline is None else deadline - time.time() 3227 try: 3228 plumbing_response = self.stub.Create( 3229 req, 3230 metadata=self.parent.get_metadata('IdentityAliases.Create', 3231 req), 3232 timeout=t) 3233 except Exception as e: 3234 if self.parent.shouldRetry(tries, e, deadline): 3235 tries += 1 3236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3237 continue 3238 raise plumbing.convert_error_to_porcelain(e) from e 3239 break 3240 3241 resp = models.IdentityAliasCreateResponse() 3242 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3243 plumbing_response.identity_alias) 3244 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3245 plumbing_response.meta) 3246 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3247 plumbing_response.rate_limit) 3248 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3250 def get(self, id, timeout=None): 3251 ''' 3252 Get reads one IdentityAlias by ID. 3253 ''' 3254 deadline = None if timeout is None else time.time() + timeout 3255 req = IdentityAliasGetRequest() 3256 if self.parent.snapshot_datetime is not None: 3257 req.meta.CopyFrom(GetRequestMetadata()) 3258 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3259 3260 req.id = (id) 3261 tries = 0 3262 plumbing_response = None 3263 while True: 3264 t = None if deadline is None else deadline - time.time() 3265 try: 3266 plumbing_response = self.stub.Get( 3267 req, 3268 metadata=self.parent.get_metadata('IdentityAliases.Get', 3269 req), 3270 timeout=t) 3271 except Exception as e: 3272 if self.parent.shouldRetry(tries, e, deadline): 3273 tries += 1 3274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3275 continue 3276 raise plumbing.convert_error_to_porcelain(e) from e 3277 break 3278 3279 resp = models.IdentityAliasGetResponse() 3280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3281 plumbing_response.identity_alias) 3282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3283 plumbing_response.meta) 3284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3285 plumbing_response.rate_limit) 3286 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3288 def update(self, identity_alias, timeout=None): 3289 ''' 3290 Update replaces all the fields of a IdentityAlias by ID. 3291 ''' 3292 deadline = None if timeout is None else time.time() + timeout 3293 req = IdentityAliasUpdateRequest() 3294 3295 if identity_alias is not None: 3296 req.identity_alias.CopyFrom( 3297 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3298 tries = 0 3299 plumbing_response = None 3300 while True: 3301 t = None if deadline is None else deadline - time.time() 3302 try: 3303 plumbing_response = self.stub.Update( 3304 req, 3305 metadata=self.parent.get_metadata('IdentityAliases.Update', 3306 req), 3307 timeout=t) 3308 except Exception as e: 3309 if self.parent.shouldRetry(tries, e, deadline): 3310 tries += 1 3311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3312 continue 3313 raise plumbing.convert_error_to_porcelain(e) from e 3314 break 3315 3316 resp = models.IdentityAliasUpdateResponse() 3317 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3318 plumbing_response.identity_alias) 3319 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3320 plumbing_response.meta) 3321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3322 plumbing_response.rate_limit) 3323 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3325 def delete(self, id, timeout=None): 3326 ''' 3327 Delete removes a IdentityAlias by ID. 3328 ''' 3329 deadline = None if timeout is None else time.time() + timeout 3330 req = IdentityAliasDeleteRequest() 3331 3332 req.id = (id) 3333 tries = 0 3334 plumbing_response = None 3335 while True: 3336 t = None if deadline is None else deadline - time.time() 3337 try: 3338 plumbing_response = self.stub.Delete( 3339 req, 3340 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3341 req), 3342 timeout=t) 3343 except Exception as e: 3344 if self.parent.shouldRetry(tries, e, deadline): 3345 tries += 1 3346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3347 continue 3348 raise plumbing.convert_error_to_porcelain(e) from e 3349 break 3350 3351 resp = models.IdentityAliasDeleteResponse() 3352 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3353 plumbing_response.meta) 3354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3355 plumbing_response.rate_limit) 3356 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3358 def list(self, filter, *args, timeout=None): 3359 ''' 3360 List gets a list of IdentityAliases matching a given set of criteria. 3361 ''' 3362 deadline = None if timeout is None else time.time() + timeout 3363 req = IdentityAliasListRequest() 3364 req.meta.CopyFrom(ListRequestMetadata()) 3365 if self.parent.page_limit > 0: 3366 req.meta.limit = self.parent.page_limit 3367 if self.parent.snapshot_datetime is not None: 3368 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3369 3370 req.filter = plumbing.quote_filter_args(filter, *args) 3371 3372 def generator(svc, req): 3373 tries = 0 3374 while True: 3375 t = None if deadline is None else deadline - time.time() 3376 try: 3377 plumbing_response = svc.stub.List( 3378 req, 3379 metadata=svc.parent.get_metadata( 3380 'IdentityAliases.List', req), 3381 timeout=t) 3382 except Exception as e: 3383 if self.parent.shouldRetry(tries, e, deadline): 3384 tries += 1 3385 time.sleep( 3386 self.parent.exponentialBackoff(tries, deadline)) 3387 continue 3388 raise plumbing.convert_error_to_porcelain(e) from e 3389 tries = 0 3390 for plumbing_item in plumbing_response.identity_aliases: 3391 yield plumbing.convert_identity_alias_to_porcelain( 3392 plumbing_item) 3393 if plumbing_response.meta.next_cursor == '': 3394 break 3395 req.meta.cursor = plumbing_response.meta.next_cursor 3396 3397 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3400class SnapshotIdentityAliases: 3401 ''' 3402 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3403 service for historical queries. 3404 ''' 3405 def __init__(self, identity_aliases): 3406 self.identity_aliases = identity_aliases 3407 3408 def get(self, id, timeout=None): 3409 ''' 3410 Get reads one IdentityAlias by ID. 3411 ''' 3412 return self.identity_aliases.get(id, timeout=timeout) 3413 3414 def list(self, filter, *args, timeout=None): 3415 ''' 3416 List gets a list of IdentityAliases matching a given set of criteria. 3417 ''' 3418 return self.identity_aliases.list(filter, *args, timeout=timeout)
SnapshotIdentityAliases exposes the read only methods of the IdentityAliases service for historical queries.
def
get(self, id, timeout=None)
3408 def get(self, id, timeout=None): 3409 ''' 3410 Get reads one IdentityAlias by ID. 3411 ''' 3412 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3414 def list(self, filter, *args, timeout=None): 3415 ''' 3416 List gets a list of IdentityAliases matching a given set of criteria. 3417 ''' 3418 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3421class IdentityAliasesHistory: 3422 ''' 3423 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3424 See `strongdm.models.IdentityAliasHistory`. 3425 ''' 3426 def __init__(self, channel, client): 3427 self.parent = client 3428 self.stub = IdentityAliasesHistoryStub(channel) 3429 3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = IdentityAliasHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'IdentityAliasesHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_identity_alias_history_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 return generator(self, req)
IdentityAliasesHistory records all changes to the state of a IdentityAlias.
See strongdm.models.IdentityAliasHistory.
def
list(self, filter, *args, timeout=None)
3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = IdentityAliasHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'IdentityAliasesHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_identity_alias_history_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3472class IdentitySets: 3473 ''' 3474 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3475 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3476 See `strongdm.models.IdentitySet`. 3477 ''' 3478 def __init__(self, channel, client): 3479 self.parent = client 3480 self.stub = IdentitySetsStub(channel) 3481 3482 def create(self, identity_set, timeout=None): 3483 ''' 3484 Create registers a new IdentitySet. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = IdentitySetCreateRequest() 3488 3489 if identity_set is not None: 3490 req.identity_set.CopyFrom( 3491 plumbing.convert_identity_set_to_plumbing(identity_set)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata('IdentitySets.Create', 3500 req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.IdentitySetCreateResponse() 3511 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3512 plumbing_response.identity_set) 3513 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3514 plumbing_response.meta) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp 3518 3519 def get(self, id, timeout=None): 3520 ''' 3521 Get reads one IdentitySet by ID. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = IdentitySetGetRequest() 3525 if self.parent.snapshot_datetime is not None: 3526 req.meta.CopyFrom(GetRequestMetadata()) 3527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3528 3529 req.id = (id) 3530 tries = 0 3531 plumbing_response = None 3532 while True: 3533 t = None if deadline is None else deadline - time.time() 3534 try: 3535 plumbing_response = self.stub.Get( 3536 req, 3537 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3538 timeout=t) 3539 except Exception as e: 3540 if self.parent.shouldRetry(tries, e, deadline): 3541 tries += 1 3542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3543 continue 3544 raise plumbing.convert_error_to_porcelain(e) from e 3545 break 3546 3547 resp = models.IdentitySetGetResponse() 3548 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3549 plumbing_response.identity_set) 3550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3551 plumbing_response.meta) 3552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3553 plumbing_response.rate_limit) 3554 return resp 3555 3556 def update(self, identity_set, timeout=None): 3557 ''' 3558 Update replaces all the fields of a IdentitySet by ID. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = IdentitySetUpdateRequest() 3562 3563 if identity_set is not None: 3564 req.identity_set.CopyFrom( 3565 plumbing.convert_identity_set_to_plumbing(identity_set)) 3566 tries = 0 3567 plumbing_response = None 3568 while True: 3569 t = None if deadline is None else deadline - time.time() 3570 try: 3571 plumbing_response = self.stub.Update( 3572 req, 3573 metadata=self.parent.get_metadata('IdentitySets.Update', 3574 req), 3575 timeout=t) 3576 except Exception as e: 3577 if self.parent.shouldRetry(tries, e, deadline): 3578 tries += 1 3579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3580 continue 3581 raise plumbing.convert_error_to_porcelain(e) from e 3582 break 3583 3584 resp = models.IdentitySetUpdateResponse() 3585 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3586 plumbing_response.identity_set) 3587 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3588 plumbing_response.meta) 3589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3590 plumbing_response.rate_limit) 3591 return resp 3592 3593 def delete(self, id, timeout=None): 3594 ''' 3595 Delete removes a IdentitySet by ID. 3596 ''' 3597 deadline = None if timeout is None else time.time() + timeout 3598 req = IdentitySetDeleteRequest() 3599 3600 req.id = (id) 3601 tries = 0 3602 plumbing_response = None 3603 while True: 3604 t = None if deadline is None else deadline - time.time() 3605 try: 3606 plumbing_response = self.stub.Delete( 3607 req, 3608 metadata=self.parent.get_metadata('IdentitySets.Delete', 3609 req), 3610 timeout=t) 3611 except Exception as e: 3612 if self.parent.shouldRetry(tries, e, deadline): 3613 tries += 1 3614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3615 continue 3616 raise plumbing.convert_error_to_porcelain(e) from e 3617 break 3618 3619 resp = models.IdentitySetDeleteResponse() 3620 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3621 plumbing_response.meta) 3622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3623 plumbing_response.rate_limit) 3624 return resp 3625 3626 def list(self, filter, *args, timeout=None): 3627 ''' 3628 List gets a list of IdentitySets matching a given set of criteria. 3629 ''' 3630 deadline = None if timeout is None else time.time() + timeout 3631 req = IdentitySetListRequest() 3632 req.meta.CopyFrom(ListRequestMetadata()) 3633 if self.parent.page_limit > 0: 3634 req.meta.limit = self.parent.page_limit 3635 if self.parent.snapshot_datetime is not None: 3636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3637 3638 req.filter = plumbing.quote_filter_args(filter, *args) 3639 3640 def generator(svc, req): 3641 tries = 0 3642 while True: 3643 t = None if deadline is None else deadline - time.time() 3644 try: 3645 plumbing_response = svc.stub.List( 3646 req, 3647 metadata=svc.parent.get_metadata( 3648 'IdentitySets.List', req), 3649 timeout=t) 3650 except Exception as e: 3651 if self.parent.shouldRetry(tries, e, deadline): 3652 tries += 1 3653 time.sleep( 3654 self.parent.exponentialBackoff(tries, deadline)) 3655 continue 3656 raise plumbing.convert_error_to_porcelain(e) from e 3657 tries = 0 3658 for plumbing_item in plumbing_response.identity_sets: 3659 yield plumbing.convert_identity_set_to_porcelain( 3660 plumbing_item) 3661 if plumbing_response.meta.next_cursor == '': 3662 break 3663 req.meta.cursor = plumbing_response.meta.next_cursor 3664 3665 return generator(self, req)
A IdentitySet is a named grouping of Identity Aliases for Accounts.
An Account's relationship to a IdentitySet is defined via IdentityAlias objects.
See strongdm.models.IdentitySet.
def
create(self, identity_set, timeout=None)
3482 def create(self, identity_set, timeout=None): 3483 ''' 3484 Create registers a new IdentitySet. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = IdentitySetCreateRequest() 3488 3489 if identity_set is not None: 3490 req.identity_set.CopyFrom( 3491 plumbing.convert_identity_set_to_plumbing(identity_set)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata('IdentitySets.Create', 3500 req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.IdentitySetCreateResponse() 3511 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3512 plumbing_response.identity_set) 3513 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3514 plumbing_response.meta) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
3519 def get(self, id, timeout=None): 3520 ''' 3521 Get reads one IdentitySet by ID. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = IdentitySetGetRequest() 3525 if self.parent.snapshot_datetime is not None: 3526 req.meta.CopyFrom(GetRequestMetadata()) 3527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3528 3529 req.id = (id) 3530 tries = 0 3531 plumbing_response = None 3532 while True: 3533 t = None if deadline is None else deadline - time.time() 3534 try: 3535 plumbing_response = self.stub.Get( 3536 req, 3537 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3538 timeout=t) 3539 except Exception as e: 3540 if self.parent.shouldRetry(tries, e, deadline): 3541 tries += 1 3542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3543 continue 3544 raise plumbing.convert_error_to_porcelain(e) from e 3545 break 3546 3547 resp = models.IdentitySetGetResponse() 3548 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3549 plumbing_response.identity_set) 3550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3551 plumbing_response.meta) 3552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3553 plumbing_response.rate_limit) 3554 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
3556 def update(self, identity_set, timeout=None): 3557 ''' 3558 Update replaces all the fields of a IdentitySet by ID. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = IdentitySetUpdateRequest() 3562 3563 if identity_set is not None: 3564 req.identity_set.CopyFrom( 3565 plumbing.convert_identity_set_to_plumbing(identity_set)) 3566 tries = 0 3567 plumbing_response = None 3568 while True: 3569 t = None if deadline is None else deadline - time.time() 3570 try: 3571 plumbing_response = self.stub.Update( 3572 req, 3573 metadata=self.parent.get_metadata('IdentitySets.Update', 3574 req), 3575 timeout=t) 3576 except Exception as e: 3577 if self.parent.shouldRetry(tries, e, deadline): 3578 tries += 1 3579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3580 continue 3581 raise plumbing.convert_error_to_porcelain(e) from e 3582 break 3583 3584 resp = models.IdentitySetUpdateResponse() 3585 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3586 plumbing_response.identity_set) 3587 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3588 plumbing_response.meta) 3589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3590 plumbing_response.rate_limit) 3591 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
3593 def delete(self, id, timeout=None): 3594 ''' 3595 Delete removes a IdentitySet by ID. 3596 ''' 3597 deadline = None if timeout is None else time.time() + timeout 3598 req = IdentitySetDeleteRequest() 3599 3600 req.id = (id) 3601 tries = 0 3602 plumbing_response = None 3603 while True: 3604 t = None if deadline is None else deadline - time.time() 3605 try: 3606 plumbing_response = self.stub.Delete( 3607 req, 3608 metadata=self.parent.get_metadata('IdentitySets.Delete', 3609 req), 3610 timeout=t) 3611 except Exception as e: 3612 if self.parent.shouldRetry(tries, e, deadline): 3613 tries += 1 3614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3615 continue 3616 raise plumbing.convert_error_to_porcelain(e) from e 3617 break 3618 3619 resp = models.IdentitySetDeleteResponse() 3620 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3621 plumbing_response.meta) 3622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3623 plumbing_response.rate_limit) 3624 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3626 def list(self, filter, *args, timeout=None): 3627 ''' 3628 List gets a list of IdentitySets matching a given set of criteria. 3629 ''' 3630 deadline = None if timeout is None else time.time() + timeout 3631 req = IdentitySetListRequest() 3632 req.meta.CopyFrom(ListRequestMetadata()) 3633 if self.parent.page_limit > 0: 3634 req.meta.limit = self.parent.page_limit 3635 if self.parent.snapshot_datetime is not None: 3636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3637 3638 req.filter = plumbing.quote_filter_args(filter, *args) 3639 3640 def generator(svc, req): 3641 tries = 0 3642 while True: 3643 t = None if deadline is None else deadline - time.time() 3644 try: 3645 plumbing_response = svc.stub.List( 3646 req, 3647 metadata=svc.parent.get_metadata( 3648 'IdentitySets.List', req), 3649 timeout=t) 3650 except Exception as e: 3651 if self.parent.shouldRetry(tries, e, deadline): 3652 tries += 1 3653 time.sleep( 3654 self.parent.exponentialBackoff(tries, deadline)) 3655 continue 3656 raise plumbing.convert_error_to_porcelain(e) from e 3657 tries = 0 3658 for plumbing_item in plumbing_response.identity_sets: 3659 yield plumbing.convert_identity_set_to_porcelain( 3660 plumbing_item) 3661 if plumbing_response.meta.next_cursor == '': 3662 break 3663 req.meta.cursor = plumbing_response.meta.next_cursor 3664 3665 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
3668class SnapshotIdentitySets: 3669 ''' 3670 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3671 service for historical queries. 3672 ''' 3673 def __init__(self, identity_sets): 3674 self.identity_sets = identity_sets 3675 3676 def get(self, id, timeout=None): 3677 ''' 3678 Get reads one IdentitySet by ID. 3679 ''' 3680 return self.identity_sets.get(id, timeout=timeout) 3681 3682 def list(self, filter, *args, timeout=None): 3683 ''' 3684 List gets a list of IdentitySets matching a given set of criteria. 3685 ''' 3686 return self.identity_sets.list(filter, *args, timeout=timeout)
SnapshotIdentitySets exposes the read only methods of the IdentitySets service for historical queries.
def
get(self, id, timeout=None)
3676 def get(self, id, timeout=None): 3677 ''' 3678 Get reads one IdentitySet by ID. 3679 ''' 3680 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3682 def list(self, filter, *args, timeout=None): 3683 ''' 3684 List gets a list of IdentitySets matching a given set of criteria. 3685 ''' 3686 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
3689class IdentitySetsHistory: 3690 ''' 3691 IdentitySetsHistory records all changes to the state of a IdentitySet. 3692 See `strongdm.models.IdentitySetHistory`. 3693 ''' 3694 def __init__(self, channel, client): 3695 self.parent = client 3696 self.stub = IdentitySetsHistoryStub(channel) 3697 3698 def list(self, filter, *args, timeout=None): 3699 ''' 3700 List gets a list of IdentitySetHistory records matching a given set of criteria. 3701 ''' 3702 deadline = None if timeout is None else time.time() + timeout 3703 req = IdentitySetHistoryListRequest() 3704 req.meta.CopyFrom(ListRequestMetadata()) 3705 if self.parent.page_limit > 0: 3706 req.meta.limit = self.parent.page_limit 3707 if self.parent.snapshot_datetime is not None: 3708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3709 3710 req.filter = plumbing.quote_filter_args(filter, *args) 3711 3712 def generator(svc, req): 3713 tries = 0 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = svc.stub.List( 3718 req, 3719 metadata=svc.parent.get_metadata( 3720 'IdentitySetsHistory.List', req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep( 3726 self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 tries = 0 3730 for plumbing_item in plumbing_response.history: 3731 yield plumbing.convert_identity_set_history_to_porcelain( 3732 plumbing_item) 3733 if plumbing_response.meta.next_cursor == '': 3734 break 3735 req.meta.cursor = plumbing_response.meta.next_cursor 3736 3737 return generator(self, req)
IdentitySetsHistory records all changes to the state of a IdentitySet.
See strongdm.models.IdentitySetHistory.
def
list(self, filter, *args, timeout=None)
3698 def list(self, filter, *args, timeout=None): 3699 ''' 3700 List gets a list of IdentitySetHistory records matching a given set of criteria. 3701 ''' 3702 deadline = None if timeout is None else time.time() + timeout 3703 req = IdentitySetHistoryListRequest() 3704 req.meta.CopyFrom(ListRequestMetadata()) 3705 if self.parent.page_limit > 0: 3706 req.meta.limit = self.parent.page_limit 3707 if self.parent.snapshot_datetime is not None: 3708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3709 3710 req.filter = plumbing.quote_filter_args(filter, *args) 3711 3712 def generator(svc, req): 3713 tries = 0 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = svc.stub.List( 3718 req, 3719 metadata=svc.parent.get_metadata( 3720 'IdentitySetsHistory.List', req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep( 3726 self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 tries = 0 3730 for plumbing_item in plumbing_response.history: 3731 yield plumbing.convert_identity_set_history_to_porcelain( 3732 plumbing_item) 3733 if plumbing_response.meta.next_cursor == '': 3734 break 3735 req.meta.cursor = plumbing_response.meta.next_cursor 3736 3737 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
3740class ManagedSecrets: 3741 ''' 3742 ManagedSecret is a private vertical for creating, reading, updating, 3743 deleting, listing and rotating the managed secrets in the secrets engines as 3744 an authenticated user. 3745 See `strongdm.models.ManagedSecret`. 3746 ''' 3747 def __init__(self, channel, client): 3748 self.parent = client 3749 self.stub = ManagedSecretsStub(channel) 3750 3751 def list(self, filter, *args, timeout=None): 3752 ''' 3753 List returns Managed Secrets from a Secret Engine. 3754 ''' 3755 deadline = None if timeout is None else time.time() + timeout 3756 req = ManagedSecretListRequest() 3757 req.meta.CopyFrom(ListRequestMetadata()) 3758 if self.parent.page_limit > 0: 3759 req.meta.limit = self.parent.page_limit 3760 if self.parent.snapshot_datetime is not None: 3761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3762 3763 req.filter = plumbing.quote_filter_args(filter, *args) 3764 3765 def generator(svc, req): 3766 tries = 0 3767 while True: 3768 t = None if deadline is None else deadline - time.time() 3769 try: 3770 plumbing_response = svc.stub.List( 3771 req, 3772 metadata=svc.parent.get_metadata( 3773 'ManagedSecrets.List', req), 3774 timeout=t) 3775 except Exception as e: 3776 if self.parent.shouldRetry(tries, e, deadline): 3777 tries += 1 3778 time.sleep( 3779 self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 tries = 0 3783 for plumbing_item in plumbing_response.managed_secrets: 3784 yield plumbing.convert_managed_secret_to_porcelain( 3785 plumbing_item) 3786 if plumbing_response.meta.next_cursor == '': 3787 break 3788 req.meta.cursor = plumbing_response.meta.next_cursor 3789 3790 return generator(self, req) 3791 3792 def list_by_actor(self, filter, *args, timeout=None): 3793 ''' 3794 List returns Managed Secrets for an Actor from a Secret Engine. 3795 ''' 3796 deadline = None if timeout is None else time.time() + timeout 3797 req = ManagedSecretListRequest() 3798 req.meta.CopyFrom(ListRequestMetadata()) 3799 if self.parent.page_limit > 0: 3800 req.meta.limit = self.parent.page_limit 3801 if self.parent.snapshot_datetime is not None: 3802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3803 3804 req.filter = plumbing.quote_filter_args(filter, *args) 3805 3806 def generator(svc, req): 3807 tries = 0 3808 while True: 3809 t = None if deadline is None else deadline - time.time() 3810 try: 3811 plumbing_response = svc.stub.ListByActor( 3812 req, 3813 metadata=svc.parent.get_metadata( 3814 'ManagedSecrets.ListByActor', req), 3815 timeout=t) 3816 except Exception as e: 3817 if self.parent.shouldRetry(tries, e, deadline): 3818 tries += 1 3819 time.sleep( 3820 self.parent.exponentialBackoff(tries, deadline)) 3821 continue 3822 raise plumbing.convert_error_to_porcelain(e) from e 3823 tries = 0 3824 for plumbing_item in plumbing_response.managed_secrets: 3825 yield plumbing.convert_managed_secret_to_porcelain( 3826 plumbing_item) 3827 if plumbing_response.meta.next_cursor == '': 3828 break 3829 req.meta.cursor = plumbing_response.meta.next_cursor 3830 3831 return generator(self, req) 3832 3833 def create(self, managed_secret, timeout=None): 3834 ''' 3835 Create creates a Managed Secret 3836 ''' 3837 deadline = None if timeout is None else time.time() + timeout 3838 req = ManagedSecretCreateRequest() 3839 3840 if managed_secret is not None: 3841 req.managed_secret.CopyFrom( 3842 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3843 tries = 0 3844 plumbing_response = None 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = self.stub.Create( 3849 req, 3850 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3851 req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3857 continue 3858 raise plumbing.convert_error_to_porcelain(e) from e 3859 break 3860 3861 resp = models.ManagedSecretCreateResponse() 3862 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3863 plumbing_response.managed_secret) 3864 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3865 plumbing_response.meta) 3866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3867 plumbing_response.rate_limit) 3868 return resp 3869 3870 def update(self, managed_secret, timeout=None): 3871 ''' 3872 Update updates a Managed Secret 3873 ''' 3874 deadline = None if timeout is None else time.time() + timeout 3875 req = ManagedSecretUpdateRequest() 3876 3877 if managed_secret is not None: 3878 req.managed_secret.CopyFrom( 3879 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3880 tries = 0 3881 plumbing_response = None 3882 while True: 3883 t = None if deadline is None else deadline - time.time() 3884 try: 3885 plumbing_response = self.stub.Update( 3886 req, 3887 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3888 req), 3889 timeout=t) 3890 except Exception as e: 3891 if self.parent.shouldRetry(tries, e, deadline): 3892 tries += 1 3893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3894 continue 3895 raise plumbing.convert_error_to_porcelain(e) from e 3896 break 3897 3898 resp = models.ManagedSecretUpdateResponse() 3899 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3900 plumbing_response.managed_secret) 3901 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3902 plumbing_response.meta) 3903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3904 plumbing_response.rate_limit) 3905 return resp 3906 3907 def rotate(self, id, timeout=None): 3908 ''' 3909 Rotate forces rotation of Managed Secret 3910 ''' 3911 deadline = None if timeout is None else time.time() + timeout 3912 req = ManagedSecretRotateRequest() 3913 3914 req.id = (id) 3915 tries = 0 3916 plumbing_response = None 3917 while True: 3918 t = None if deadline is None else deadline - time.time() 3919 try: 3920 plumbing_response = self.stub.Rotate( 3921 req, 3922 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3923 req), 3924 timeout=t) 3925 except Exception as e: 3926 if self.parent.shouldRetry(tries, e, deadline): 3927 tries += 1 3928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3929 continue 3930 raise plumbing.convert_error_to_porcelain(e) from e 3931 break 3932 3933 resp = models.ManagedSecretRotateResponse() 3934 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3935 plumbing_response.meta) 3936 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3937 plumbing_response.rate_limit) 3938 return resp 3939 3940 def delete(self, id, timeout=None): 3941 ''' 3942 Delete deletes a Managed Secret 3943 ''' 3944 deadline = None if timeout is None else time.time() + timeout 3945 req = ManagedSecretDeleteRequest() 3946 3947 req.id = (id) 3948 tries = 0 3949 plumbing_response = None 3950 while True: 3951 t = None if deadline is None else deadline - time.time() 3952 try: 3953 plumbing_response = self.stub.Delete( 3954 req, 3955 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3956 req), 3957 timeout=t) 3958 except Exception as e: 3959 if self.parent.shouldRetry(tries, e, deadline): 3960 tries += 1 3961 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3962 continue 3963 raise plumbing.convert_error_to_porcelain(e) from e 3964 break 3965 3966 resp = models.ManagedSecretDeleteResponse() 3967 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3968 plumbing_response.rate_limit) 3969 return resp 3970 3971 def force_delete(self, id, timeout=None): 3972 ''' 3973 ForceDelete deletes a Managed Secret regardless of errors on external system 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = ManagedSecretDeleteRequest() 3977 3978 req.id = (id) 3979 tries = 0 3980 plumbing_response = None 3981 while True: 3982 t = None if deadline is None else deadline - time.time() 3983 try: 3984 plumbing_response = self.stub.ForceDelete( 3985 req, 3986 metadata=self.parent.get_metadata( 3987 'ManagedSecrets.ForceDelete', req), 3988 timeout=t) 3989 except Exception as e: 3990 if self.parent.shouldRetry(tries, e, deadline): 3991 tries += 1 3992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3993 continue 3994 raise plumbing.convert_error_to_porcelain(e) from e 3995 break 3996 3997 resp = models.ManagedSecretDeleteResponse() 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp 4001 4002 def get(self, id, timeout=None): 4003 ''' 4004 Get gets details of a Managed Secret without sensitive data 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = ManagedSecretGetRequest() 4008 if self.parent.snapshot_datetime is not None: 4009 req.meta.CopyFrom(GetRequestMetadata()) 4010 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4011 4012 req.id = (id) 4013 tries = 0 4014 plumbing_response = None 4015 while True: 4016 t = None if deadline is None else deadline - time.time() 4017 try: 4018 plumbing_response = self.stub.Get( 4019 req, 4020 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4021 req), 4022 timeout=t) 4023 except Exception as e: 4024 if self.parent.shouldRetry(tries, e, deadline): 4025 tries += 1 4026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4027 continue 4028 raise plumbing.convert_error_to_porcelain(e) from e 4029 break 4030 4031 resp = models.ManagedSecretGetResponse() 4032 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4033 plumbing_response.managed_secret) 4034 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4035 plumbing_response.meta) 4036 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4037 plumbing_response.rate_limit) 4038 return resp 4039 4040 def retrieve(self, id, public_key, timeout=None): 4041 ''' 4042 Retrieve returns Managed Secret with sensitive data 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = ManagedSecretRetrieveRequest() 4046 4047 req.id = (id) 4048 req.public_key = (public_key) 4049 tries = 0 4050 plumbing_response = None 4051 while True: 4052 t = None if deadline is None else deadline - time.time() 4053 try: 4054 plumbing_response = self.stub.Retrieve( 4055 req, 4056 metadata=self.parent.get_metadata( 4057 'ManagedSecrets.Retrieve', req), 4058 timeout=t) 4059 except Exception as e: 4060 if self.parent.shouldRetry(tries, e, deadline): 4061 tries += 1 4062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4063 continue 4064 raise plumbing.convert_error_to_porcelain(e) from e 4065 break 4066 4067 resp = models.ManagedSecretRetrieveResponse() 4068 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4069 plumbing_response.managed_secret) 4070 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4073 plumbing_response.rate_limit) 4074 return resp 4075 4076 def validate(self, id, timeout=None): 4077 ''' 4078 Validate returns the result of testing the stored credential against the 4079 secret engine. 4080 ''' 4081 deadline = None if timeout is None else time.time() + timeout 4082 req = ManagedSecretValidateRequest() 4083 4084 req.id = (id) 4085 tries = 0 4086 plumbing_response = None 4087 while True: 4088 t = None if deadline is None else deadline - time.time() 4089 try: 4090 plumbing_response = self.stub.Validate( 4091 req, 4092 metadata=self.parent.get_metadata( 4093 'ManagedSecrets.Validate', req), 4094 timeout=t) 4095 except Exception as e: 4096 if self.parent.shouldRetry(tries, e, deadline): 4097 tries += 1 4098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4099 continue 4100 raise plumbing.convert_error_to_porcelain(e) from e 4101 break 4102 4103 resp = models.ManagedSecretValidateResponse() 4104 resp.invalid_info = (plumbing_response.invalid_info) 4105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4106 plumbing_response.meta) 4107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4108 plumbing_response.rate_limit) 4109 resp.valid = (plumbing_response.valid) 4110 return resp 4111 4112 def logs(self, filter, *args, timeout=None): 4113 ''' 4114 Logs returns the audit records for the managed secret. This may be replaced 4115 in the future. 4116 ''' 4117 deadline = None if timeout is None else time.time() + timeout 4118 req = ManagedSecretLogsRequest() 4119 req.meta.CopyFrom(ListRequestMetadata()) 4120 if self.parent.page_limit > 0: 4121 req.meta.limit = self.parent.page_limit 4122 if self.parent.snapshot_datetime is not None: 4123 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4124 4125 req.filter = plumbing.quote_filter_args(filter, *args) 4126 4127 def generator(svc, req): 4128 tries = 0 4129 while True: 4130 t = None if deadline is None else deadline - time.time() 4131 try: 4132 plumbing_response = svc.stub.Logs( 4133 req, 4134 metadata=svc.parent.get_metadata( 4135 'ManagedSecrets.Logs', req), 4136 timeout=t) 4137 except Exception as e: 4138 if self.parent.shouldRetry(tries, e, deadline): 4139 tries += 1 4140 time.sleep( 4141 self.parent.exponentialBackoff(tries, deadline)) 4142 continue 4143 raise plumbing.convert_error_to_porcelain(e) from e 4144 tries = 0 4145 for plumbing_item in plumbing_response.managed_secret_logs: 4146 yield plumbing.convert_managed_secret_log_to_porcelain( 4147 plumbing_item) 4148 if plumbing_response.meta.next_cursor == '': 4149 break 4150 req.meta.cursor = plumbing_response.meta.next_cursor 4151 4152 return generator(self, req)
ManagedSecret is a private vertical for creating, reading, updating,
deleting, listing and rotating the managed secrets in the secrets engines as
an authenticated user.
See strongdm.models.ManagedSecret.
def
list(self, filter, *args, timeout=None)
3751 def list(self, filter, *args, timeout=None): 3752 ''' 3753 List returns Managed Secrets from a Secret Engine. 3754 ''' 3755 deadline = None if timeout is None else time.time() + timeout 3756 req = ManagedSecretListRequest() 3757 req.meta.CopyFrom(ListRequestMetadata()) 3758 if self.parent.page_limit > 0: 3759 req.meta.limit = self.parent.page_limit 3760 if self.parent.snapshot_datetime is not None: 3761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3762 3763 req.filter = plumbing.quote_filter_args(filter, *args) 3764 3765 def generator(svc, req): 3766 tries = 0 3767 while True: 3768 t = None if deadline is None else deadline - time.time() 3769 try: 3770 plumbing_response = svc.stub.List( 3771 req, 3772 metadata=svc.parent.get_metadata( 3773 'ManagedSecrets.List', req), 3774 timeout=t) 3775 except Exception as e: 3776 if self.parent.shouldRetry(tries, e, deadline): 3777 tries += 1 3778 time.sleep( 3779 self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 tries = 0 3783 for plumbing_item in plumbing_response.managed_secrets: 3784 yield plumbing.convert_managed_secret_to_porcelain( 3785 plumbing_item) 3786 if plumbing_response.meta.next_cursor == '': 3787 break 3788 req.meta.cursor = plumbing_response.meta.next_cursor 3789 3790 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
3792 def list_by_actor(self, filter, *args, timeout=None): 3793 ''' 3794 List returns Managed Secrets for an Actor from a Secret Engine. 3795 ''' 3796 deadline = None if timeout is None else time.time() + timeout 3797 req = ManagedSecretListRequest() 3798 req.meta.CopyFrom(ListRequestMetadata()) 3799 if self.parent.page_limit > 0: 3800 req.meta.limit = self.parent.page_limit 3801 if self.parent.snapshot_datetime is not None: 3802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3803 3804 req.filter = plumbing.quote_filter_args(filter, *args) 3805 3806 def generator(svc, req): 3807 tries = 0 3808 while True: 3809 t = None if deadline is None else deadline - time.time() 3810 try: 3811 plumbing_response = svc.stub.ListByActor( 3812 req, 3813 metadata=svc.parent.get_metadata( 3814 'ManagedSecrets.ListByActor', req), 3815 timeout=t) 3816 except Exception as e: 3817 if self.parent.shouldRetry(tries, e, deadline): 3818 tries += 1 3819 time.sleep( 3820 self.parent.exponentialBackoff(tries, deadline)) 3821 continue 3822 raise plumbing.convert_error_to_porcelain(e) from e 3823 tries = 0 3824 for plumbing_item in plumbing_response.managed_secrets: 3825 yield plumbing.convert_managed_secret_to_porcelain( 3826 plumbing_item) 3827 if plumbing_response.meta.next_cursor == '': 3828 break 3829 req.meta.cursor = plumbing_response.meta.next_cursor 3830 3831 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
3833 def create(self, managed_secret, timeout=None): 3834 ''' 3835 Create creates a Managed Secret 3836 ''' 3837 deadline = None if timeout is None else time.time() + timeout 3838 req = ManagedSecretCreateRequest() 3839 3840 if managed_secret is not None: 3841 req.managed_secret.CopyFrom( 3842 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3843 tries = 0 3844 plumbing_response = None 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = self.stub.Create( 3849 req, 3850 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3851 req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3857 continue 3858 raise plumbing.convert_error_to_porcelain(e) from e 3859 break 3860 3861 resp = models.ManagedSecretCreateResponse() 3862 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3863 plumbing_response.managed_secret) 3864 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3865 plumbing_response.meta) 3866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3867 plumbing_response.rate_limit) 3868 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
3870 def update(self, managed_secret, timeout=None): 3871 ''' 3872 Update updates a Managed Secret 3873 ''' 3874 deadline = None if timeout is None else time.time() + timeout 3875 req = ManagedSecretUpdateRequest() 3876 3877 if managed_secret is not None: 3878 req.managed_secret.CopyFrom( 3879 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3880 tries = 0 3881 plumbing_response = None 3882 while True: 3883 t = None if deadline is None else deadline - time.time() 3884 try: 3885 plumbing_response = self.stub.Update( 3886 req, 3887 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3888 req), 3889 timeout=t) 3890 except Exception as e: 3891 if self.parent.shouldRetry(tries, e, deadline): 3892 tries += 1 3893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3894 continue 3895 raise plumbing.convert_error_to_porcelain(e) from e 3896 break 3897 3898 resp = models.ManagedSecretUpdateResponse() 3899 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3900 plumbing_response.managed_secret) 3901 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3902 plumbing_response.meta) 3903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3904 plumbing_response.rate_limit) 3905 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
3907 def rotate(self, id, timeout=None): 3908 ''' 3909 Rotate forces rotation of Managed Secret 3910 ''' 3911 deadline = None if timeout is None else time.time() + timeout 3912 req = ManagedSecretRotateRequest() 3913 3914 req.id = (id) 3915 tries = 0 3916 plumbing_response = None 3917 while True: 3918 t = None if deadline is None else deadline - time.time() 3919 try: 3920 plumbing_response = self.stub.Rotate( 3921 req, 3922 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3923 req), 3924 timeout=t) 3925 except Exception as e: 3926 if self.parent.shouldRetry(tries, e, deadline): 3927 tries += 1 3928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3929 continue 3930 raise plumbing.convert_error_to_porcelain(e) from e 3931 break 3932 3933 resp = models.ManagedSecretRotateResponse() 3934 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3935 plumbing_response.meta) 3936 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3937 plumbing_response.rate_limit) 3938 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
3940 def delete(self, id, timeout=None): 3941 ''' 3942 Delete deletes a Managed Secret 3943 ''' 3944 deadline = None if timeout is None else time.time() + timeout 3945 req = ManagedSecretDeleteRequest() 3946 3947 req.id = (id) 3948 tries = 0 3949 plumbing_response = None 3950 while True: 3951 t = None if deadline is None else deadline - time.time() 3952 try: 3953 plumbing_response = self.stub.Delete( 3954 req, 3955 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3956 req), 3957 timeout=t) 3958 except Exception as e: 3959 if self.parent.shouldRetry(tries, e, deadline): 3960 tries += 1 3961 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3962 continue 3963 raise plumbing.convert_error_to_porcelain(e) from e 3964 break 3965 3966 resp = models.ManagedSecretDeleteResponse() 3967 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3968 plumbing_response.rate_limit) 3969 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
3971 def force_delete(self, id, timeout=None): 3972 ''' 3973 ForceDelete deletes a Managed Secret regardless of errors on external system 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = ManagedSecretDeleteRequest() 3977 3978 req.id = (id) 3979 tries = 0 3980 plumbing_response = None 3981 while True: 3982 t = None if deadline is None else deadline - time.time() 3983 try: 3984 plumbing_response = self.stub.ForceDelete( 3985 req, 3986 metadata=self.parent.get_metadata( 3987 'ManagedSecrets.ForceDelete', req), 3988 timeout=t) 3989 except Exception as e: 3990 if self.parent.shouldRetry(tries, e, deadline): 3991 tries += 1 3992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3993 continue 3994 raise plumbing.convert_error_to_porcelain(e) from e 3995 break 3996 3997 resp = models.ManagedSecretDeleteResponse() 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4002 def get(self, id, timeout=None): 4003 ''' 4004 Get gets details of a Managed Secret without sensitive data 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = ManagedSecretGetRequest() 4008 if self.parent.snapshot_datetime is not None: 4009 req.meta.CopyFrom(GetRequestMetadata()) 4010 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4011 4012 req.id = (id) 4013 tries = 0 4014 plumbing_response = None 4015 while True: 4016 t = None if deadline is None else deadline - time.time() 4017 try: 4018 plumbing_response = self.stub.Get( 4019 req, 4020 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4021 req), 4022 timeout=t) 4023 except Exception as e: 4024 if self.parent.shouldRetry(tries, e, deadline): 4025 tries += 1 4026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4027 continue 4028 raise plumbing.convert_error_to_porcelain(e) from e 4029 break 4030 4031 resp = models.ManagedSecretGetResponse() 4032 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4033 plumbing_response.managed_secret) 4034 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4035 plumbing_response.meta) 4036 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4037 plumbing_response.rate_limit) 4038 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, public_key, timeout=None)
4040 def retrieve(self, id, public_key, timeout=None): 4041 ''' 4042 Retrieve returns Managed Secret with sensitive data 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = ManagedSecretRetrieveRequest() 4046 4047 req.id = (id) 4048 req.public_key = (public_key) 4049 tries = 0 4050 plumbing_response = None 4051 while True: 4052 t = None if deadline is None else deadline - time.time() 4053 try: 4054 plumbing_response = self.stub.Retrieve( 4055 req, 4056 metadata=self.parent.get_metadata( 4057 'ManagedSecrets.Retrieve', req), 4058 timeout=t) 4059 except Exception as e: 4060 if self.parent.shouldRetry(tries, e, deadline): 4061 tries += 1 4062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4063 continue 4064 raise plumbing.convert_error_to_porcelain(e) from e 4065 break 4066 4067 resp = models.ManagedSecretRetrieveResponse() 4068 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4069 plumbing_response.managed_secret) 4070 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4073 plumbing_response.rate_limit) 4074 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4076 def validate(self, id, timeout=None): 4077 ''' 4078 Validate returns the result of testing the stored credential against the 4079 secret engine. 4080 ''' 4081 deadline = None if timeout is None else time.time() + timeout 4082 req = ManagedSecretValidateRequest() 4083 4084 req.id = (id) 4085 tries = 0 4086 plumbing_response = None 4087 while True: 4088 t = None if deadline is None else deadline - time.time() 4089 try: 4090 plumbing_response = self.stub.Validate( 4091 req, 4092 metadata=self.parent.get_metadata( 4093 'ManagedSecrets.Validate', req), 4094 timeout=t) 4095 except Exception as e: 4096 if self.parent.shouldRetry(tries, e, deadline): 4097 tries += 1 4098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4099 continue 4100 raise plumbing.convert_error_to_porcelain(e) from e 4101 break 4102 4103 resp = models.ManagedSecretValidateResponse() 4104 resp.invalid_info = (plumbing_response.invalid_info) 4105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4106 plumbing_response.meta) 4107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4108 plumbing_response.rate_limit) 4109 resp.valid = (plumbing_response.valid) 4110 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4112 def logs(self, filter, *args, timeout=None): 4113 ''' 4114 Logs returns the audit records for the managed secret. This may be replaced 4115 in the future. 4116 ''' 4117 deadline = None if timeout is None else time.time() + timeout 4118 req = ManagedSecretLogsRequest() 4119 req.meta.CopyFrom(ListRequestMetadata()) 4120 if self.parent.page_limit > 0: 4121 req.meta.limit = self.parent.page_limit 4122 if self.parent.snapshot_datetime is not None: 4123 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4124 4125 req.filter = plumbing.quote_filter_args(filter, *args) 4126 4127 def generator(svc, req): 4128 tries = 0 4129 while True: 4130 t = None if deadline is None else deadline - time.time() 4131 try: 4132 plumbing_response = svc.stub.Logs( 4133 req, 4134 metadata=svc.parent.get_metadata( 4135 'ManagedSecrets.Logs', req), 4136 timeout=t) 4137 except Exception as e: 4138 if self.parent.shouldRetry(tries, e, deadline): 4139 tries += 1 4140 time.sleep( 4141 self.parent.exponentialBackoff(tries, deadline)) 4142 continue 4143 raise plumbing.convert_error_to_porcelain(e) from e 4144 tries = 0 4145 for plumbing_item in plumbing_response.managed_secret_logs: 4146 yield plumbing.convert_managed_secret_log_to_porcelain( 4147 plumbing_item) 4148 if plumbing_response.meta.next_cursor == '': 4149 break 4150 req.meta.cursor = plumbing_response.meta.next_cursor 4151 4152 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4155class Nodes: 4156 ''' 4157 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 4158 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 4159 - **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. 4160 See: 4161 `strongdm.models.Gateway` 4162 `strongdm.models.ProxyCluster` 4163 `strongdm.models.Relay` 4164 ''' 4165 def __init__(self, channel, client): 4166 self.parent = client 4167 self.stub = NodesStub(channel) 4168 4169 def create(self, node, timeout=None): 4170 ''' 4171 Create registers a new Node. 4172 ''' 4173 deadline = None if timeout is None else time.time() + timeout 4174 req = NodeCreateRequest() 4175 4176 if node is not None: 4177 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4178 tries = 0 4179 plumbing_response = None 4180 while True: 4181 t = None if deadline is None else deadline - time.time() 4182 try: 4183 plumbing_response = self.stub.Create( 4184 req, 4185 metadata=self.parent.get_metadata('Nodes.Create', req), 4186 timeout=t) 4187 except Exception as e: 4188 if self.parent.shouldRetry(tries, e, deadline): 4189 tries += 1 4190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4191 continue 4192 raise plumbing.convert_error_to_porcelain(e) from e 4193 break 4194 4195 resp = models.NodeCreateResponse() 4196 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4197 plumbing_response.meta) 4198 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4200 plumbing_response.rate_limit) 4201 resp.token = (plumbing_response.token) 4202 return resp 4203 4204 def get(self, id, timeout=None): 4205 ''' 4206 Get reads one Node by ID. 4207 ''' 4208 deadline = None if timeout is None else time.time() + timeout 4209 req = NodeGetRequest() 4210 if self.parent.snapshot_datetime is not None: 4211 req.meta.CopyFrom(GetRequestMetadata()) 4212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4213 4214 req.id = (id) 4215 tries = 0 4216 plumbing_response = None 4217 while True: 4218 t = None if deadline is None else deadline - time.time() 4219 try: 4220 plumbing_response = self.stub.Get( 4221 req, 4222 metadata=self.parent.get_metadata('Nodes.Get', req), 4223 timeout=t) 4224 except Exception as e: 4225 if self.parent.shouldRetry(tries, e, deadline): 4226 tries += 1 4227 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4228 continue 4229 raise plumbing.convert_error_to_porcelain(e) from e 4230 break 4231 4232 resp = models.NodeGetResponse() 4233 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4234 plumbing_response.meta) 4235 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4236 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4237 plumbing_response.rate_limit) 4238 return resp 4239 4240 def update(self, node, timeout=None): 4241 ''' 4242 Update replaces all the fields of a Node by ID. 4243 ''' 4244 deadline = None if timeout is None else time.time() + timeout 4245 req = NodeUpdateRequest() 4246 4247 if node is not None: 4248 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4249 tries = 0 4250 plumbing_response = None 4251 while True: 4252 t = None if deadline is None else deadline - time.time() 4253 try: 4254 plumbing_response = self.stub.Update( 4255 req, 4256 metadata=self.parent.get_metadata('Nodes.Update', req), 4257 timeout=t) 4258 except Exception as e: 4259 if self.parent.shouldRetry(tries, e, deadline): 4260 tries += 1 4261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4262 continue 4263 raise plumbing.convert_error_to_porcelain(e) from e 4264 break 4265 4266 resp = models.NodeUpdateResponse() 4267 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4268 plumbing_response.meta) 4269 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4271 plumbing_response.rate_limit) 4272 return resp 4273 4274 def delete(self, id, timeout=None): 4275 ''' 4276 Delete removes a Node by ID. 4277 ''' 4278 deadline = None if timeout is None else time.time() + timeout 4279 req = NodeDeleteRequest() 4280 4281 req.id = (id) 4282 tries = 0 4283 plumbing_response = None 4284 while True: 4285 t = None if deadline is None else deadline - time.time() 4286 try: 4287 plumbing_response = self.stub.Delete( 4288 req, 4289 metadata=self.parent.get_metadata('Nodes.Delete', req), 4290 timeout=t) 4291 except Exception as e: 4292 if self.parent.shouldRetry(tries, e, deadline): 4293 tries += 1 4294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4295 continue 4296 raise plumbing.convert_error_to_porcelain(e) from e 4297 break 4298 4299 resp = models.NodeDeleteResponse() 4300 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4301 plumbing_response.meta) 4302 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4303 plumbing_response.rate_limit) 4304 return resp 4305 4306 def list(self, filter, *args, timeout=None): 4307 ''' 4308 List gets a list of Nodes matching a given set of criteria. 4309 ''' 4310 deadline = None if timeout is None else time.time() + timeout 4311 req = NodeListRequest() 4312 req.meta.CopyFrom(ListRequestMetadata()) 4313 if self.parent.page_limit > 0: 4314 req.meta.limit = self.parent.page_limit 4315 if self.parent.snapshot_datetime is not None: 4316 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4317 4318 req.filter = plumbing.quote_filter_args(filter, *args) 4319 4320 def generator(svc, req): 4321 tries = 0 4322 while True: 4323 t = None if deadline is None else deadline - time.time() 4324 try: 4325 plumbing_response = svc.stub.List( 4326 req, 4327 metadata=svc.parent.get_metadata('Nodes.List', req), 4328 timeout=t) 4329 except Exception as e: 4330 if self.parent.shouldRetry(tries, e, deadline): 4331 tries += 1 4332 time.sleep( 4333 self.parent.exponentialBackoff(tries, deadline)) 4334 continue 4335 raise plumbing.convert_error_to_porcelain(e) from e 4336 tries = 0 4337 for plumbing_item in plumbing_response.nodes: 4338 yield plumbing.convert_node_to_porcelain(plumbing_item) 4339 if plumbing_response.meta.next_cursor == '': 4340 break 4341 req.meta.cursor = plumbing_response.meta.next_cursor 4342 4343 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)
4169 def create(self, node, timeout=None): 4170 ''' 4171 Create registers a new Node. 4172 ''' 4173 deadline = None if timeout is None else time.time() + timeout 4174 req = NodeCreateRequest() 4175 4176 if node is not None: 4177 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4178 tries = 0 4179 plumbing_response = None 4180 while True: 4181 t = None if deadline is None else deadline - time.time() 4182 try: 4183 plumbing_response = self.stub.Create( 4184 req, 4185 metadata=self.parent.get_metadata('Nodes.Create', req), 4186 timeout=t) 4187 except Exception as e: 4188 if self.parent.shouldRetry(tries, e, deadline): 4189 tries += 1 4190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4191 continue 4192 raise plumbing.convert_error_to_porcelain(e) from e 4193 break 4194 4195 resp = models.NodeCreateResponse() 4196 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4197 plumbing_response.meta) 4198 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4200 plumbing_response.rate_limit) 4201 resp.token = (plumbing_response.token) 4202 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4204 def get(self, id, timeout=None): 4205 ''' 4206 Get reads one Node by ID. 4207 ''' 4208 deadline = None if timeout is None else time.time() + timeout 4209 req = NodeGetRequest() 4210 if self.parent.snapshot_datetime is not None: 4211 req.meta.CopyFrom(GetRequestMetadata()) 4212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4213 4214 req.id = (id) 4215 tries = 0 4216 plumbing_response = None 4217 while True: 4218 t = None if deadline is None else deadline - time.time() 4219 try: 4220 plumbing_response = self.stub.Get( 4221 req, 4222 metadata=self.parent.get_metadata('Nodes.Get', req), 4223 timeout=t) 4224 except Exception as e: 4225 if self.parent.shouldRetry(tries, e, deadline): 4226 tries += 1 4227 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4228 continue 4229 raise plumbing.convert_error_to_porcelain(e) from e 4230 break 4231 4232 resp = models.NodeGetResponse() 4233 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4234 plumbing_response.meta) 4235 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4236 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4237 plumbing_response.rate_limit) 4238 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4240 def update(self, node, timeout=None): 4241 ''' 4242 Update replaces all the fields of a Node by ID. 4243 ''' 4244 deadline = None if timeout is None else time.time() + timeout 4245 req = NodeUpdateRequest() 4246 4247 if node is not None: 4248 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4249 tries = 0 4250 plumbing_response = None 4251 while True: 4252 t = None if deadline is None else deadline - time.time() 4253 try: 4254 plumbing_response = self.stub.Update( 4255 req, 4256 metadata=self.parent.get_metadata('Nodes.Update', req), 4257 timeout=t) 4258 except Exception as e: 4259 if self.parent.shouldRetry(tries, e, deadline): 4260 tries += 1 4261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4262 continue 4263 raise plumbing.convert_error_to_porcelain(e) from e 4264 break 4265 4266 resp = models.NodeUpdateResponse() 4267 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4268 plumbing_response.meta) 4269 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4271 plumbing_response.rate_limit) 4272 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4274 def delete(self, id, timeout=None): 4275 ''' 4276 Delete removes a Node by ID. 4277 ''' 4278 deadline = None if timeout is None else time.time() + timeout 4279 req = NodeDeleteRequest() 4280 4281 req.id = (id) 4282 tries = 0 4283 plumbing_response = None 4284 while True: 4285 t = None if deadline is None else deadline - time.time() 4286 try: 4287 plumbing_response = self.stub.Delete( 4288 req, 4289 metadata=self.parent.get_metadata('Nodes.Delete', req), 4290 timeout=t) 4291 except Exception as e: 4292 if self.parent.shouldRetry(tries, e, deadline): 4293 tries += 1 4294 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4295 continue 4296 raise plumbing.convert_error_to_porcelain(e) from e 4297 break 4298 4299 resp = models.NodeDeleteResponse() 4300 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4301 plumbing_response.meta) 4302 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4303 plumbing_response.rate_limit) 4304 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4306 def list(self, filter, *args, timeout=None): 4307 ''' 4308 List gets a list of Nodes matching a given set of criteria. 4309 ''' 4310 deadline = None if timeout is None else time.time() + timeout 4311 req = NodeListRequest() 4312 req.meta.CopyFrom(ListRequestMetadata()) 4313 if self.parent.page_limit > 0: 4314 req.meta.limit = self.parent.page_limit 4315 if self.parent.snapshot_datetime is not None: 4316 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4317 4318 req.filter = plumbing.quote_filter_args(filter, *args) 4319 4320 def generator(svc, req): 4321 tries = 0 4322 while True: 4323 t = None if deadline is None else deadline - time.time() 4324 try: 4325 plumbing_response = svc.stub.List( 4326 req, 4327 metadata=svc.parent.get_metadata('Nodes.List', req), 4328 timeout=t) 4329 except Exception as e: 4330 if self.parent.shouldRetry(tries, e, deadline): 4331 tries += 1 4332 time.sleep( 4333 self.parent.exponentialBackoff(tries, deadline)) 4334 continue 4335 raise plumbing.convert_error_to_porcelain(e) from e 4336 tries = 0 4337 for plumbing_item in plumbing_response.nodes: 4338 yield plumbing.convert_node_to_porcelain(plumbing_item) 4339 if plumbing_response.meta.next_cursor == '': 4340 break 4341 req.meta.cursor = plumbing_response.meta.next_cursor 4342 4343 return generator(self, req)
List gets a list of Nodes matching a given set of criteria.
class
SnapshotNodes:
4346class SnapshotNodes: 4347 ''' 4348 SnapshotNodes exposes the read only methods of the Nodes 4349 service for historical queries. 4350 ''' 4351 def __init__(self, nodes): 4352 self.nodes = nodes 4353 4354 def get(self, id, timeout=None): 4355 ''' 4356 Get reads one Node by ID. 4357 ''' 4358 return self.nodes.get(id, timeout=timeout) 4359 4360 def list(self, filter, *args, timeout=None): 4361 ''' 4362 List gets a list of Nodes matching a given set of criteria. 4363 ''' 4364 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4367class NodesHistory: 4368 ''' 4369 NodesHistory records all changes to the state of a Node. 4370 See `strongdm.models.NodeHistory`. 4371 ''' 4372 def __init__(self, channel, client): 4373 self.parent = client 4374 self.stub = NodesHistoryStub(channel) 4375 4376 def list(self, filter, *args, timeout=None): 4377 ''' 4378 List gets a list of NodeHistory records matching a given set of criteria. 4379 ''' 4380 deadline = None if timeout is None else time.time() + timeout 4381 req = NodeHistoryListRequest() 4382 req.meta.CopyFrom(ListRequestMetadata()) 4383 if self.parent.page_limit > 0: 4384 req.meta.limit = self.parent.page_limit 4385 if self.parent.snapshot_datetime is not None: 4386 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4387 4388 req.filter = plumbing.quote_filter_args(filter, *args) 4389 4390 def generator(svc, req): 4391 tries = 0 4392 while True: 4393 t = None if deadline is None else deadline - time.time() 4394 try: 4395 plumbing_response = svc.stub.List( 4396 req, 4397 metadata=svc.parent.get_metadata( 4398 'NodesHistory.List', req), 4399 timeout=t) 4400 except Exception as e: 4401 if self.parent.shouldRetry(tries, e, deadline): 4402 tries += 1 4403 time.sleep( 4404 self.parent.exponentialBackoff(tries, deadline)) 4405 continue 4406 raise plumbing.convert_error_to_porcelain(e) from e 4407 tries = 0 4408 for plumbing_item in plumbing_response.history: 4409 yield plumbing.convert_node_history_to_porcelain( 4410 plumbing_item) 4411 if plumbing_response.meta.next_cursor == '': 4412 break 4413 req.meta.cursor = plumbing_response.meta.next_cursor 4414 4415 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)
4376 def list(self, filter, *args, timeout=None): 4377 ''' 4378 List gets a list of NodeHistory records matching a given set of criteria. 4379 ''' 4380 deadline = None if timeout is None else time.time() + timeout 4381 req = NodeHistoryListRequest() 4382 req.meta.CopyFrom(ListRequestMetadata()) 4383 if self.parent.page_limit > 0: 4384 req.meta.limit = self.parent.page_limit 4385 if self.parent.snapshot_datetime is not None: 4386 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4387 4388 req.filter = plumbing.quote_filter_args(filter, *args) 4389 4390 def generator(svc, req): 4391 tries = 0 4392 while True: 4393 t = None if deadline is None else deadline - time.time() 4394 try: 4395 plumbing_response = svc.stub.List( 4396 req, 4397 metadata=svc.parent.get_metadata( 4398 'NodesHistory.List', req), 4399 timeout=t) 4400 except Exception as e: 4401 if self.parent.shouldRetry(tries, e, deadline): 4402 tries += 1 4403 time.sleep( 4404 self.parent.exponentialBackoff(tries, deadline)) 4405 continue 4406 raise plumbing.convert_error_to_porcelain(e) from e 4407 tries = 0 4408 for plumbing_item in plumbing_response.history: 4409 yield plumbing.convert_node_history_to_porcelain( 4410 plumbing_item) 4411 if plumbing_response.meta.next_cursor == '': 4412 break 4413 req.meta.cursor = plumbing_response.meta.next_cursor 4414 4415 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4418class OrganizationHistory: 4419 ''' 4420 OrganizationHistory records all changes to the state of an Organization. 4421 See `strongdm.models.OrganizationHistoryRecord`. 4422 ''' 4423 def __init__(self, channel, client): 4424 self.parent = client 4425 self.stub = OrganizationHistoryStub(channel) 4426 4427 def list(self, filter, *args, timeout=None): 4428 ''' 4429 List gets a list of OrganizationHistory records matching a given set of criteria. 4430 ''' 4431 deadline = None if timeout is None else time.time() + timeout 4432 req = OrganizationHistoryListRequest() 4433 req.meta.CopyFrom(ListRequestMetadata()) 4434 if self.parent.page_limit > 0: 4435 req.meta.limit = self.parent.page_limit 4436 if self.parent.snapshot_datetime is not None: 4437 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4438 4439 req.filter = plumbing.quote_filter_args(filter, *args) 4440 4441 def generator(svc, req): 4442 tries = 0 4443 while True: 4444 t = None if deadline is None else deadline - time.time() 4445 try: 4446 plumbing_response = svc.stub.List( 4447 req, 4448 metadata=svc.parent.get_metadata( 4449 'OrganizationHistory.List', req), 4450 timeout=t) 4451 except Exception as e: 4452 if self.parent.shouldRetry(tries, e, deadline): 4453 tries += 1 4454 time.sleep( 4455 self.parent.exponentialBackoff(tries, deadline)) 4456 continue 4457 raise plumbing.convert_error_to_porcelain(e) from e 4458 tries = 0 4459 for plumbing_item in plumbing_response.history: 4460 yield plumbing.convert_organization_history_record_to_porcelain( 4461 plumbing_item) 4462 if plumbing_response.meta.next_cursor == '': 4463 break 4464 req.meta.cursor = plumbing_response.meta.next_cursor 4465 4466 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)
4427 def list(self, filter, *args, timeout=None): 4428 ''' 4429 List gets a list of OrganizationHistory records matching a given set of criteria. 4430 ''' 4431 deadline = None if timeout is None else time.time() + timeout 4432 req = OrganizationHistoryListRequest() 4433 req.meta.CopyFrom(ListRequestMetadata()) 4434 if self.parent.page_limit > 0: 4435 req.meta.limit = self.parent.page_limit 4436 if self.parent.snapshot_datetime is not None: 4437 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4438 4439 req.filter = plumbing.quote_filter_args(filter, *args) 4440 4441 def generator(svc, req): 4442 tries = 0 4443 while True: 4444 t = None if deadline is None else deadline - time.time() 4445 try: 4446 plumbing_response = svc.stub.List( 4447 req, 4448 metadata=svc.parent.get_metadata( 4449 'OrganizationHistory.List', req), 4450 timeout=t) 4451 except Exception as e: 4452 if self.parent.shouldRetry(tries, e, deadline): 4453 tries += 1 4454 time.sleep( 4455 self.parent.exponentialBackoff(tries, deadline)) 4456 continue 4457 raise plumbing.convert_error_to_porcelain(e) from e 4458 tries = 0 4459 for plumbing_item in plumbing_response.history: 4460 yield plumbing.convert_organization_history_record_to_porcelain( 4461 plumbing_item) 4462 if plumbing_response.meta.next_cursor == '': 4463 break 4464 req.meta.cursor = plumbing_response.meta.next_cursor 4465 4466 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
4469class PeeringGroupNodes: 4470 ''' 4471 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4472 See `strongdm.models.PeeringGroupNode`. 4473 ''' 4474 def __init__(self, channel, client): 4475 self.parent = client 4476 self.stub = PeeringGroupNodesStub(channel) 4477 4478 def create(self, peering_group_node, timeout=None): 4479 ''' 4480 Create attaches a Node to a PeeringGroup 4481 ''' 4482 deadline = None if timeout is None else time.time() + timeout 4483 req = PeeringGroupNodeCreateRequest() 4484 4485 if peering_group_node is not None: 4486 req.peering_group_node.CopyFrom( 4487 plumbing.convert_peering_group_node_to_plumbing( 4488 peering_group_node)) 4489 tries = 0 4490 plumbing_response = None 4491 while True: 4492 t = None if deadline is None else deadline - time.time() 4493 try: 4494 plumbing_response = self.stub.Create( 4495 req, 4496 metadata=self.parent.get_metadata( 4497 'PeeringGroupNodes.Create', req), 4498 timeout=t) 4499 except Exception as e: 4500 if self.parent.shouldRetry(tries, e, deadline): 4501 tries += 1 4502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4503 continue 4504 raise plumbing.convert_error_to_porcelain(e) from e 4505 break 4506 4507 resp = models.PeeringGroupNodeCreateResponse() 4508 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4509 plumbing_response.meta) 4510 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4511 plumbing_response.peering_group_node) 4512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4513 plumbing_response.rate_limit) 4514 return resp 4515 4516 def delete(self, id, timeout=None): 4517 ''' 4518 Delete detaches a Node to a PeeringGroup. 4519 ''' 4520 deadline = None if timeout is None else time.time() + timeout 4521 req = PeeringGroupNodeDeleteRequest() 4522 4523 req.id = (id) 4524 tries = 0 4525 plumbing_response = None 4526 while True: 4527 t = None if deadline is None else deadline - time.time() 4528 try: 4529 plumbing_response = self.stub.Delete( 4530 req, 4531 metadata=self.parent.get_metadata( 4532 'PeeringGroupNodes.Delete', req), 4533 timeout=t) 4534 except Exception as e: 4535 if self.parent.shouldRetry(tries, e, deadline): 4536 tries += 1 4537 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4538 continue 4539 raise plumbing.convert_error_to_porcelain(e) from e 4540 break 4541 4542 resp = models.PeeringGroupNodeDeleteResponse() 4543 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4544 plumbing_response.meta) 4545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4546 plumbing_response.rate_limit) 4547 return resp 4548 4549 def get(self, id, timeout=None): 4550 ''' 4551 Get reads the information of one peering group to node attachment. 4552 ''' 4553 deadline = None if timeout is None else time.time() + timeout 4554 req = PeeringGroupNodeGetRequest() 4555 if self.parent.snapshot_datetime is not None: 4556 req.meta.CopyFrom(GetRequestMetadata()) 4557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4558 4559 req.id = (id) 4560 tries = 0 4561 plumbing_response = None 4562 while True: 4563 t = None if deadline is None else deadline - time.time() 4564 try: 4565 plumbing_response = self.stub.Get( 4566 req, 4567 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4568 req), 4569 timeout=t) 4570 except Exception as e: 4571 if self.parent.shouldRetry(tries, e, deadline): 4572 tries += 1 4573 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4574 continue 4575 raise plumbing.convert_error_to_porcelain(e) from e 4576 break 4577 4578 resp = models.PeeringGroupNodeGetResponse() 4579 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4580 plumbing_response.meta) 4581 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4582 plumbing_response.peering_group_node) 4583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4584 plumbing_response.rate_limit) 4585 return resp 4586 4587 def list(self, filter, *args, timeout=None): 4588 ''' 4589 List gets a list of peering group node attachments. 4590 ''' 4591 deadline = None if timeout is None else time.time() + timeout 4592 req = PeeringGroupNodeListRequest() 4593 req.meta.CopyFrom(ListRequestMetadata()) 4594 if self.parent.page_limit > 0: 4595 req.meta.limit = self.parent.page_limit 4596 if self.parent.snapshot_datetime is not None: 4597 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4598 4599 req.filter = plumbing.quote_filter_args(filter, *args) 4600 4601 def generator(svc, req): 4602 tries = 0 4603 while True: 4604 t = None if deadline is None else deadline - time.time() 4605 try: 4606 plumbing_response = svc.stub.List( 4607 req, 4608 metadata=svc.parent.get_metadata( 4609 'PeeringGroupNodes.List', req), 4610 timeout=t) 4611 except Exception as e: 4612 if self.parent.shouldRetry(tries, e, deadline): 4613 tries += 1 4614 time.sleep( 4615 self.parent.exponentialBackoff(tries, deadline)) 4616 continue 4617 raise plumbing.convert_error_to_porcelain(e) from e 4618 tries = 0 4619 for plumbing_item in plumbing_response.peering_group_nodes: 4620 yield plumbing.convert_peering_group_node_to_porcelain( 4621 plumbing_item) 4622 if plumbing_response.meta.next_cursor == '': 4623 break 4624 req.meta.cursor = plumbing_response.meta.next_cursor 4625 4626 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)
4478 def create(self, peering_group_node, timeout=None): 4479 ''' 4480 Create attaches a Node to a PeeringGroup 4481 ''' 4482 deadline = None if timeout is None else time.time() + timeout 4483 req = PeeringGroupNodeCreateRequest() 4484 4485 if peering_group_node is not None: 4486 req.peering_group_node.CopyFrom( 4487 plumbing.convert_peering_group_node_to_plumbing( 4488 peering_group_node)) 4489 tries = 0 4490 plumbing_response = None 4491 while True: 4492 t = None if deadline is None else deadline - time.time() 4493 try: 4494 plumbing_response = self.stub.Create( 4495 req, 4496 metadata=self.parent.get_metadata( 4497 'PeeringGroupNodes.Create', req), 4498 timeout=t) 4499 except Exception as e: 4500 if self.parent.shouldRetry(tries, e, deadline): 4501 tries += 1 4502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4503 continue 4504 raise plumbing.convert_error_to_porcelain(e) from e 4505 break 4506 4507 resp = models.PeeringGroupNodeCreateResponse() 4508 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4509 plumbing_response.meta) 4510 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4511 plumbing_response.peering_group_node) 4512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4513 plumbing_response.rate_limit) 4514 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
4516 def delete(self, id, timeout=None): 4517 ''' 4518 Delete detaches a Node to a PeeringGroup. 4519 ''' 4520 deadline = None if timeout is None else time.time() + timeout 4521 req = PeeringGroupNodeDeleteRequest() 4522 4523 req.id = (id) 4524 tries = 0 4525 plumbing_response = None 4526 while True: 4527 t = None if deadline is None else deadline - time.time() 4528 try: 4529 plumbing_response = self.stub.Delete( 4530 req, 4531 metadata=self.parent.get_metadata( 4532 'PeeringGroupNodes.Delete', req), 4533 timeout=t) 4534 except Exception as e: 4535 if self.parent.shouldRetry(tries, e, deadline): 4536 tries += 1 4537 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4538 continue 4539 raise plumbing.convert_error_to_porcelain(e) from e 4540 break 4541 4542 resp = models.PeeringGroupNodeDeleteResponse() 4543 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4544 plumbing_response.meta) 4545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4546 plumbing_response.rate_limit) 4547 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
4549 def get(self, id, timeout=None): 4550 ''' 4551 Get reads the information of one peering group to node attachment. 4552 ''' 4553 deadline = None if timeout is None else time.time() + timeout 4554 req = PeeringGroupNodeGetRequest() 4555 if self.parent.snapshot_datetime is not None: 4556 req.meta.CopyFrom(GetRequestMetadata()) 4557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4558 4559 req.id = (id) 4560 tries = 0 4561 plumbing_response = None 4562 while True: 4563 t = None if deadline is None else deadline - time.time() 4564 try: 4565 plumbing_response = self.stub.Get( 4566 req, 4567 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4568 req), 4569 timeout=t) 4570 except Exception as e: 4571 if self.parent.shouldRetry(tries, e, deadline): 4572 tries += 1 4573 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4574 continue 4575 raise plumbing.convert_error_to_porcelain(e) from e 4576 break 4577 4578 resp = models.PeeringGroupNodeGetResponse() 4579 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4580 plumbing_response.meta) 4581 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4582 plumbing_response.peering_group_node) 4583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4584 plumbing_response.rate_limit) 4585 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
4587 def list(self, filter, *args, timeout=None): 4588 ''' 4589 List gets a list of peering group node attachments. 4590 ''' 4591 deadline = None if timeout is None else time.time() + timeout 4592 req = PeeringGroupNodeListRequest() 4593 req.meta.CopyFrom(ListRequestMetadata()) 4594 if self.parent.page_limit > 0: 4595 req.meta.limit = self.parent.page_limit 4596 if self.parent.snapshot_datetime is not None: 4597 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4598 4599 req.filter = plumbing.quote_filter_args(filter, *args) 4600 4601 def generator(svc, req): 4602 tries = 0 4603 while True: 4604 t = None if deadline is None else deadline - time.time() 4605 try: 4606 plumbing_response = svc.stub.List( 4607 req, 4608 metadata=svc.parent.get_metadata( 4609 'PeeringGroupNodes.List', req), 4610 timeout=t) 4611 except Exception as e: 4612 if self.parent.shouldRetry(tries, e, deadline): 4613 tries += 1 4614 time.sleep( 4615 self.parent.exponentialBackoff(tries, deadline)) 4616 continue 4617 raise plumbing.convert_error_to_porcelain(e) from e 4618 tries = 0 4619 for plumbing_item in plumbing_response.peering_group_nodes: 4620 yield plumbing.convert_peering_group_node_to_porcelain( 4621 plumbing_item) 4622 if plumbing_response.meta.next_cursor == '': 4623 break 4624 req.meta.cursor = plumbing_response.meta.next_cursor 4625 4626 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
4629class PeeringGroupPeers: 4630 ''' 4631 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4632 See `strongdm.models.PeeringGroupPeer`. 4633 ''' 4634 def __init__(self, channel, client): 4635 self.parent = client 4636 self.stub = PeeringGroupPeersStub(channel) 4637 4638 def create(self, peering_group_peer, timeout=None): 4639 ''' 4640 Create links two peering groups. 4641 ''' 4642 deadline = None if timeout is None else time.time() + timeout 4643 req = PeeringGroupPeerCreateRequest() 4644 4645 if peering_group_peer is not None: 4646 req.peering_group_peer.CopyFrom( 4647 plumbing.convert_peering_group_peer_to_plumbing( 4648 peering_group_peer)) 4649 tries = 0 4650 plumbing_response = None 4651 while True: 4652 t = None if deadline is None else deadline - time.time() 4653 try: 4654 plumbing_response = self.stub.Create( 4655 req, 4656 metadata=self.parent.get_metadata( 4657 'PeeringGroupPeers.Create', req), 4658 timeout=t) 4659 except Exception as e: 4660 if self.parent.shouldRetry(tries, e, deadline): 4661 tries += 1 4662 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4663 continue 4664 raise plumbing.convert_error_to_porcelain(e) from e 4665 break 4666 4667 resp = models.PeeringGroupPeerCreateResponse() 4668 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4669 plumbing_response.meta) 4670 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4671 plumbing_response.peering_group_peer) 4672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4673 plumbing_response.rate_limit) 4674 return resp 4675 4676 def delete(self, id, timeout=None): 4677 ''' 4678 Delete unlinks two peering groups. 4679 ''' 4680 deadline = None if timeout is None else time.time() + timeout 4681 req = PeeringGroupPeerDeleteRequest() 4682 4683 req.id = (id) 4684 tries = 0 4685 plumbing_response = None 4686 while True: 4687 t = None if deadline is None else deadline - time.time() 4688 try: 4689 plumbing_response = self.stub.Delete( 4690 req, 4691 metadata=self.parent.get_metadata( 4692 'PeeringGroupPeers.Delete', req), 4693 timeout=t) 4694 except Exception as e: 4695 if self.parent.shouldRetry(tries, e, deadline): 4696 tries += 1 4697 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4698 continue 4699 raise plumbing.convert_error_to_porcelain(e) from e 4700 break 4701 4702 resp = models.PeeringGroupPeerDeleteResponse() 4703 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4704 plumbing_response.meta) 4705 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4706 plumbing_response.rate_limit) 4707 return resp 4708 4709 def get(self, id, timeout=None): 4710 ''' 4711 Get reads the information of one peering group link. 4712 ''' 4713 deadline = None if timeout is None else time.time() + timeout 4714 req = PeeringGroupPeerGetRequest() 4715 if self.parent.snapshot_datetime is not None: 4716 req.meta.CopyFrom(GetRequestMetadata()) 4717 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4718 4719 req.id = (id) 4720 tries = 0 4721 plumbing_response = None 4722 while True: 4723 t = None if deadline is None else deadline - time.time() 4724 try: 4725 plumbing_response = self.stub.Get( 4726 req, 4727 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4728 req), 4729 timeout=t) 4730 except Exception as e: 4731 if self.parent.shouldRetry(tries, e, deadline): 4732 tries += 1 4733 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4734 continue 4735 raise plumbing.convert_error_to_porcelain(e) from e 4736 break 4737 4738 resp = models.PeeringGroupPeerGetResponse() 4739 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4740 plumbing_response.meta) 4741 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4742 plumbing_response.peering_group_peer) 4743 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4744 plumbing_response.rate_limit) 4745 return resp 4746 4747 def list(self, filter, *args, timeout=None): 4748 ''' 4749 List gets a list of peering group links. 4750 ''' 4751 deadline = None if timeout is None else time.time() + timeout 4752 req = PeeringGroupPeerListRequest() 4753 req.meta.CopyFrom(ListRequestMetadata()) 4754 if self.parent.page_limit > 0: 4755 req.meta.limit = self.parent.page_limit 4756 if self.parent.snapshot_datetime is not None: 4757 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4758 4759 req.filter = plumbing.quote_filter_args(filter, *args) 4760 4761 def generator(svc, req): 4762 tries = 0 4763 while True: 4764 t = None if deadline is None else deadline - time.time() 4765 try: 4766 plumbing_response = svc.stub.List( 4767 req, 4768 metadata=svc.parent.get_metadata( 4769 'PeeringGroupPeers.List', req), 4770 timeout=t) 4771 except Exception as e: 4772 if self.parent.shouldRetry(tries, e, deadline): 4773 tries += 1 4774 time.sleep( 4775 self.parent.exponentialBackoff(tries, deadline)) 4776 continue 4777 raise plumbing.convert_error_to_porcelain(e) from e 4778 tries = 0 4779 for plumbing_item in plumbing_response.peering_group_peers: 4780 yield plumbing.convert_peering_group_peer_to_porcelain( 4781 plumbing_item) 4782 if plumbing_response.meta.next_cursor == '': 4783 break 4784 req.meta.cursor = plumbing_response.meta.next_cursor 4785 4786 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)
4638 def create(self, peering_group_peer, timeout=None): 4639 ''' 4640 Create links two peering groups. 4641 ''' 4642 deadline = None if timeout is None else time.time() + timeout 4643 req = PeeringGroupPeerCreateRequest() 4644 4645 if peering_group_peer is not None: 4646 req.peering_group_peer.CopyFrom( 4647 plumbing.convert_peering_group_peer_to_plumbing( 4648 peering_group_peer)) 4649 tries = 0 4650 plumbing_response = None 4651 while True: 4652 t = None if deadline is None else deadline - time.time() 4653 try: 4654 plumbing_response = self.stub.Create( 4655 req, 4656 metadata=self.parent.get_metadata( 4657 'PeeringGroupPeers.Create', req), 4658 timeout=t) 4659 except Exception as e: 4660 if self.parent.shouldRetry(tries, e, deadline): 4661 tries += 1 4662 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4663 continue 4664 raise plumbing.convert_error_to_porcelain(e) from e 4665 break 4666 4667 resp = models.PeeringGroupPeerCreateResponse() 4668 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4669 plumbing_response.meta) 4670 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4671 plumbing_response.peering_group_peer) 4672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4673 plumbing_response.rate_limit) 4674 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
4676 def delete(self, id, timeout=None): 4677 ''' 4678 Delete unlinks two peering groups. 4679 ''' 4680 deadline = None if timeout is None else time.time() + timeout 4681 req = PeeringGroupPeerDeleteRequest() 4682 4683 req.id = (id) 4684 tries = 0 4685 plumbing_response = None 4686 while True: 4687 t = None if deadline is None else deadline - time.time() 4688 try: 4689 plumbing_response = self.stub.Delete( 4690 req, 4691 metadata=self.parent.get_metadata( 4692 'PeeringGroupPeers.Delete', req), 4693 timeout=t) 4694 except Exception as e: 4695 if self.parent.shouldRetry(tries, e, deadline): 4696 tries += 1 4697 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4698 continue 4699 raise plumbing.convert_error_to_porcelain(e) from e 4700 break 4701 4702 resp = models.PeeringGroupPeerDeleteResponse() 4703 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4704 plumbing_response.meta) 4705 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4706 plumbing_response.rate_limit) 4707 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
4709 def get(self, id, timeout=None): 4710 ''' 4711 Get reads the information of one peering group link. 4712 ''' 4713 deadline = None if timeout is None else time.time() + timeout 4714 req = PeeringGroupPeerGetRequest() 4715 if self.parent.snapshot_datetime is not None: 4716 req.meta.CopyFrom(GetRequestMetadata()) 4717 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4718 4719 req.id = (id) 4720 tries = 0 4721 plumbing_response = None 4722 while True: 4723 t = None if deadline is None else deadline - time.time() 4724 try: 4725 plumbing_response = self.stub.Get( 4726 req, 4727 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4728 req), 4729 timeout=t) 4730 except Exception as e: 4731 if self.parent.shouldRetry(tries, e, deadline): 4732 tries += 1 4733 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4734 continue 4735 raise plumbing.convert_error_to_porcelain(e) from e 4736 break 4737 4738 resp = models.PeeringGroupPeerGetResponse() 4739 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4740 plumbing_response.meta) 4741 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4742 plumbing_response.peering_group_peer) 4743 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4744 plumbing_response.rate_limit) 4745 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
4747 def list(self, filter, *args, timeout=None): 4748 ''' 4749 List gets a list of peering group links. 4750 ''' 4751 deadline = None if timeout is None else time.time() + timeout 4752 req = PeeringGroupPeerListRequest() 4753 req.meta.CopyFrom(ListRequestMetadata()) 4754 if self.parent.page_limit > 0: 4755 req.meta.limit = self.parent.page_limit 4756 if self.parent.snapshot_datetime is not None: 4757 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4758 4759 req.filter = plumbing.quote_filter_args(filter, *args) 4760 4761 def generator(svc, req): 4762 tries = 0 4763 while True: 4764 t = None if deadline is None else deadline - time.time() 4765 try: 4766 plumbing_response = svc.stub.List( 4767 req, 4768 metadata=svc.parent.get_metadata( 4769 'PeeringGroupPeers.List', req), 4770 timeout=t) 4771 except Exception as e: 4772 if self.parent.shouldRetry(tries, e, deadline): 4773 tries += 1 4774 time.sleep( 4775 self.parent.exponentialBackoff(tries, deadline)) 4776 continue 4777 raise plumbing.convert_error_to_porcelain(e) from e 4778 tries = 0 4779 for plumbing_item in plumbing_response.peering_group_peers: 4780 yield plumbing.convert_peering_group_peer_to_porcelain( 4781 plumbing_item) 4782 if plumbing_response.meta.next_cursor == '': 4783 break 4784 req.meta.cursor = plumbing_response.meta.next_cursor 4785 4786 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
4789class PeeringGroupResources: 4790 ''' 4791 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4792 See `strongdm.models.PeeringGroupResource`. 4793 ''' 4794 def __init__(self, channel, client): 4795 self.parent = client 4796 self.stub = PeeringGroupResourcesStub(channel) 4797 4798 def create(self, peering_group_resource, timeout=None): 4799 ''' 4800 Create attaches a Resource to a PeeringGroup 4801 ''' 4802 deadline = None if timeout is None else time.time() + timeout 4803 req = PeeringGroupResourceCreateRequest() 4804 4805 if peering_group_resource is not None: 4806 req.peering_group_resource.CopyFrom( 4807 plumbing.convert_peering_group_resource_to_plumbing( 4808 peering_group_resource)) 4809 tries = 0 4810 plumbing_response = None 4811 while True: 4812 t = None if deadline is None else deadline - time.time() 4813 try: 4814 plumbing_response = self.stub.Create( 4815 req, 4816 metadata=self.parent.get_metadata( 4817 'PeeringGroupResources.Create', req), 4818 timeout=t) 4819 except Exception as e: 4820 if self.parent.shouldRetry(tries, e, deadline): 4821 tries += 1 4822 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4823 continue 4824 raise plumbing.convert_error_to_porcelain(e) from e 4825 break 4826 4827 resp = models.PeeringGroupResourceCreateResponse() 4828 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4829 plumbing_response.meta) 4830 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4831 plumbing_response.peering_group_resource) 4832 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4833 plumbing_response.rate_limit) 4834 return resp 4835 4836 def delete(self, id, timeout=None): 4837 ''' 4838 Delete detaches a Resource to a PeeringGroup 4839 ''' 4840 deadline = None if timeout is None else time.time() + timeout 4841 req = PeeringGroupResourceDeleteRequest() 4842 4843 req.id = (id) 4844 tries = 0 4845 plumbing_response = None 4846 while True: 4847 t = None if deadline is None else deadline - time.time() 4848 try: 4849 plumbing_response = self.stub.Delete( 4850 req, 4851 metadata=self.parent.get_metadata( 4852 'PeeringGroupResources.Delete', req), 4853 timeout=t) 4854 except Exception as e: 4855 if self.parent.shouldRetry(tries, e, deadline): 4856 tries += 1 4857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4858 continue 4859 raise plumbing.convert_error_to_porcelain(e) from e 4860 break 4861 4862 resp = models.PeeringGroupResourceDeleteResponse() 4863 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4864 plumbing_response.meta) 4865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4866 plumbing_response.rate_limit) 4867 return resp 4868 4869 def get(self, id, timeout=None): 4870 ''' 4871 Get reads the information of one peering group to resource attachment. 4872 ''' 4873 deadline = None if timeout is None else time.time() + timeout 4874 req = PeeringGroupResourceGetRequest() 4875 if self.parent.snapshot_datetime is not None: 4876 req.meta.CopyFrom(GetRequestMetadata()) 4877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4878 4879 req.id = (id) 4880 tries = 0 4881 plumbing_response = None 4882 while True: 4883 t = None if deadline is None else deadline - time.time() 4884 try: 4885 plumbing_response = self.stub.Get( 4886 req, 4887 metadata=self.parent.get_metadata( 4888 'PeeringGroupResources.Get', req), 4889 timeout=t) 4890 except Exception as e: 4891 if self.parent.shouldRetry(tries, e, deadline): 4892 tries += 1 4893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4894 continue 4895 raise plumbing.convert_error_to_porcelain(e) from e 4896 break 4897 4898 resp = models.PeeringGroupResourceGetResponse() 4899 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4900 plumbing_response.meta) 4901 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4902 plumbing_response.peering_group_resource) 4903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4904 plumbing_response.rate_limit) 4905 return resp 4906 4907 def list(self, filter, *args, timeout=None): 4908 ''' 4909 List gets a list of peering group resource attachments. 4910 ''' 4911 deadline = None if timeout is None else time.time() + timeout 4912 req = PeeringGroupResourceListRequest() 4913 req.meta.CopyFrom(ListRequestMetadata()) 4914 if self.parent.page_limit > 0: 4915 req.meta.limit = self.parent.page_limit 4916 if self.parent.snapshot_datetime is not None: 4917 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4918 4919 req.filter = plumbing.quote_filter_args(filter, *args) 4920 4921 def generator(svc, req): 4922 tries = 0 4923 while True: 4924 t = None if deadline is None else deadline - time.time() 4925 try: 4926 plumbing_response = svc.stub.List( 4927 req, 4928 metadata=svc.parent.get_metadata( 4929 'PeeringGroupResources.List', req), 4930 timeout=t) 4931 except Exception as e: 4932 if self.parent.shouldRetry(tries, e, deadline): 4933 tries += 1 4934 time.sleep( 4935 self.parent.exponentialBackoff(tries, deadline)) 4936 continue 4937 raise plumbing.convert_error_to_porcelain(e) from e 4938 tries = 0 4939 for plumbing_item in plumbing_response.peering_group_resources: 4940 yield plumbing.convert_peering_group_resource_to_porcelain( 4941 plumbing_item) 4942 if plumbing_response.meta.next_cursor == '': 4943 break 4944 req.meta.cursor = plumbing_response.meta.next_cursor 4945 4946 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)
4798 def create(self, peering_group_resource, timeout=None): 4799 ''' 4800 Create attaches a Resource to a PeeringGroup 4801 ''' 4802 deadline = None if timeout is None else time.time() + timeout 4803 req = PeeringGroupResourceCreateRequest() 4804 4805 if peering_group_resource is not None: 4806 req.peering_group_resource.CopyFrom( 4807 plumbing.convert_peering_group_resource_to_plumbing( 4808 peering_group_resource)) 4809 tries = 0 4810 plumbing_response = None 4811 while True: 4812 t = None if deadline is None else deadline - time.time() 4813 try: 4814 plumbing_response = self.stub.Create( 4815 req, 4816 metadata=self.parent.get_metadata( 4817 'PeeringGroupResources.Create', req), 4818 timeout=t) 4819 except Exception as e: 4820 if self.parent.shouldRetry(tries, e, deadline): 4821 tries += 1 4822 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4823 continue 4824 raise plumbing.convert_error_to_porcelain(e) from e 4825 break 4826 4827 resp = models.PeeringGroupResourceCreateResponse() 4828 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4829 plumbing_response.meta) 4830 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4831 plumbing_response.peering_group_resource) 4832 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4833 plumbing_response.rate_limit) 4834 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
4836 def delete(self, id, timeout=None): 4837 ''' 4838 Delete detaches a Resource to a PeeringGroup 4839 ''' 4840 deadline = None if timeout is None else time.time() + timeout 4841 req = PeeringGroupResourceDeleteRequest() 4842 4843 req.id = (id) 4844 tries = 0 4845 plumbing_response = None 4846 while True: 4847 t = None if deadline is None else deadline - time.time() 4848 try: 4849 plumbing_response = self.stub.Delete( 4850 req, 4851 metadata=self.parent.get_metadata( 4852 'PeeringGroupResources.Delete', req), 4853 timeout=t) 4854 except Exception as e: 4855 if self.parent.shouldRetry(tries, e, deadline): 4856 tries += 1 4857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4858 continue 4859 raise plumbing.convert_error_to_porcelain(e) from e 4860 break 4861 4862 resp = models.PeeringGroupResourceDeleteResponse() 4863 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4864 plumbing_response.meta) 4865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4866 plumbing_response.rate_limit) 4867 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
4869 def get(self, id, timeout=None): 4870 ''' 4871 Get reads the information of one peering group to resource attachment. 4872 ''' 4873 deadline = None if timeout is None else time.time() + timeout 4874 req = PeeringGroupResourceGetRequest() 4875 if self.parent.snapshot_datetime is not None: 4876 req.meta.CopyFrom(GetRequestMetadata()) 4877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4878 4879 req.id = (id) 4880 tries = 0 4881 plumbing_response = None 4882 while True: 4883 t = None if deadline is None else deadline - time.time() 4884 try: 4885 plumbing_response = self.stub.Get( 4886 req, 4887 metadata=self.parent.get_metadata( 4888 'PeeringGroupResources.Get', req), 4889 timeout=t) 4890 except Exception as e: 4891 if self.parent.shouldRetry(tries, e, deadline): 4892 tries += 1 4893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4894 continue 4895 raise plumbing.convert_error_to_porcelain(e) from e 4896 break 4897 4898 resp = models.PeeringGroupResourceGetResponse() 4899 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4900 plumbing_response.meta) 4901 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4902 plumbing_response.peering_group_resource) 4903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4904 plumbing_response.rate_limit) 4905 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
4907 def list(self, filter, *args, timeout=None): 4908 ''' 4909 List gets a list of peering group resource attachments. 4910 ''' 4911 deadline = None if timeout is None else time.time() + timeout 4912 req = PeeringGroupResourceListRequest() 4913 req.meta.CopyFrom(ListRequestMetadata()) 4914 if self.parent.page_limit > 0: 4915 req.meta.limit = self.parent.page_limit 4916 if self.parent.snapshot_datetime is not None: 4917 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4918 4919 req.filter = plumbing.quote_filter_args(filter, *args) 4920 4921 def generator(svc, req): 4922 tries = 0 4923 while True: 4924 t = None if deadline is None else deadline - time.time() 4925 try: 4926 plumbing_response = svc.stub.List( 4927 req, 4928 metadata=svc.parent.get_metadata( 4929 'PeeringGroupResources.List', req), 4930 timeout=t) 4931 except Exception as e: 4932 if self.parent.shouldRetry(tries, e, deadline): 4933 tries += 1 4934 time.sleep( 4935 self.parent.exponentialBackoff(tries, deadline)) 4936 continue 4937 raise plumbing.convert_error_to_porcelain(e) from e 4938 tries = 0 4939 for plumbing_item in plumbing_response.peering_group_resources: 4940 yield plumbing.convert_peering_group_resource_to_porcelain( 4941 plumbing_item) 4942 if plumbing_response.meta.next_cursor == '': 4943 break 4944 req.meta.cursor = plumbing_response.meta.next_cursor 4945 4946 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
4949class PeeringGroups: 4950 ''' 4951 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4952 See `strongdm.models.PeeringGroup`. 4953 ''' 4954 def __init__(self, channel, client): 4955 self.parent = client 4956 self.stub = PeeringGroupsStub(channel) 4957 4958 def create(self, peering_group, timeout=None): 4959 ''' 4960 Create registers a new PeeringGroup. 4961 ''' 4962 deadline = None if timeout is None else time.time() + timeout 4963 req = PeeringGroupCreateRequest() 4964 4965 if peering_group is not None: 4966 req.peering_group.CopyFrom( 4967 plumbing.convert_peering_group_to_plumbing(peering_group)) 4968 tries = 0 4969 plumbing_response = None 4970 while True: 4971 t = None if deadline is None else deadline - time.time() 4972 try: 4973 plumbing_response = self.stub.Create( 4974 req, 4975 metadata=self.parent.get_metadata('PeeringGroups.Create', 4976 req), 4977 timeout=t) 4978 except Exception as e: 4979 if self.parent.shouldRetry(tries, e, deadline): 4980 tries += 1 4981 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4982 continue 4983 raise plumbing.convert_error_to_porcelain(e) from e 4984 break 4985 4986 resp = models.PeeringGroupCreateResponse() 4987 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4988 plumbing_response.meta) 4989 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4990 plumbing_response.peering_group) 4991 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4992 plumbing_response.rate_limit) 4993 return resp 4994 4995 def delete(self, id, timeout=None): 4996 ''' 4997 Delete removes a PeeringGroup by ID. 4998 ''' 4999 deadline = None if timeout is None else time.time() + timeout 5000 req = PeeringGroupDeleteRequest() 5001 5002 req.id = (id) 5003 tries = 0 5004 plumbing_response = None 5005 while True: 5006 t = None if deadline is None else deadline - time.time() 5007 try: 5008 plumbing_response = self.stub.Delete( 5009 req, 5010 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5011 req), 5012 timeout=t) 5013 except Exception as e: 5014 if self.parent.shouldRetry(tries, e, deadline): 5015 tries += 1 5016 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5017 continue 5018 raise plumbing.convert_error_to_porcelain(e) from e 5019 break 5020 5021 resp = models.PeeringGroupDeleteResponse() 5022 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5023 plumbing_response.meta) 5024 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5025 plumbing_response.rate_limit) 5026 return resp 5027 5028 def get(self, id, timeout=None): 5029 ''' 5030 Get reads one PeeringGroup by ID. It will load all its dependencies. 5031 ''' 5032 deadline = None if timeout is None else time.time() + timeout 5033 req = PeeringGroupGetRequest() 5034 if self.parent.snapshot_datetime is not None: 5035 req.meta.CopyFrom(GetRequestMetadata()) 5036 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5037 5038 req.id = (id) 5039 tries = 0 5040 plumbing_response = None 5041 while True: 5042 t = None if deadline is None else deadline - time.time() 5043 try: 5044 plumbing_response = self.stub.Get( 5045 req, 5046 metadata=self.parent.get_metadata('PeeringGroups.Get', 5047 req), 5048 timeout=t) 5049 except Exception as e: 5050 if self.parent.shouldRetry(tries, e, deadline): 5051 tries += 1 5052 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5053 continue 5054 raise plumbing.convert_error_to_porcelain(e) from e 5055 break 5056 5057 resp = models.PeeringGroupGetResponse() 5058 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5059 plumbing_response.meta) 5060 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5061 plumbing_response.peering_group) 5062 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5063 plumbing_response.rate_limit) 5064 return resp 5065 5066 def list(self, filter, *args, timeout=None): 5067 ''' 5068 List gets a list of Peering Groups. 5069 ''' 5070 deadline = None if timeout is None else time.time() + timeout 5071 req = PeeringGroupListRequest() 5072 req.meta.CopyFrom(ListRequestMetadata()) 5073 if self.parent.page_limit > 0: 5074 req.meta.limit = self.parent.page_limit 5075 if self.parent.snapshot_datetime is not None: 5076 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5077 5078 req.filter = plumbing.quote_filter_args(filter, *args) 5079 5080 def generator(svc, req): 5081 tries = 0 5082 while True: 5083 t = None if deadline is None else deadline - time.time() 5084 try: 5085 plumbing_response = svc.stub.List( 5086 req, 5087 metadata=svc.parent.get_metadata( 5088 'PeeringGroups.List', req), 5089 timeout=t) 5090 except Exception as e: 5091 if self.parent.shouldRetry(tries, e, deadline): 5092 tries += 1 5093 time.sleep( 5094 self.parent.exponentialBackoff(tries, deadline)) 5095 continue 5096 raise plumbing.convert_error_to_porcelain(e) from e 5097 tries = 0 5098 for plumbing_item in plumbing_response.peering_groups: 5099 yield plumbing.convert_peering_group_to_porcelain( 5100 plumbing_item) 5101 if plumbing_response.meta.next_cursor == '': 5102 break 5103 req.meta.cursor = plumbing_response.meta.next_cursor 5104 5105 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)
4958 def create(self, peering_group, timeout=None): 4959 ''' 4960 Create registers a new PeeringGroup. 4961 ''' 4962 deadline = None if timeout is None else time.time() + timeout 4963 req = PeeringGroupCreateRequest() 4964 4965 if peering_group is not None: 4966 req.peering_group.CopyFrom( 4967 plumbing.convert_peering_group_to_plumbing(peering_group)) 4968 tries = 0 4969 plumbing_response = None 4970 while True: 4971 t = None if deadline is None else deadline - time.time() 4972 try: 4973 plumbing_response = self.stub.Create( 4974 req, 4975 metadata=self.parent.get_metadata('PeeringGroups.Create', 4976 req), 4977 timeout=t) 4978 except Exception as e: 4979 if self.parent.shouldRetry(tries, e, deadline): 4980 tries += 1 4981 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4982 continue 4983 raise plumbing.convert_error_to_porcelain(e) from e 4984 break 4985 4986 resp = models.PeeringGroupCreateResponse() 4987 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4988 plumbing_response.meta) 4989 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4990 plumbing_response.peering_group) 4991 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4992 plumbing_response.rate_limit) 4993 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
4995 def delete(self, id, timeout=None): 4996 ''' 4997 Delete removes a PeeringGroup by ID. 4998 ''' 4999 deadline = None if timeout is None else time.time() + timeout 5000 req = PeeringGroupDeleteRequest() 5001 5002 req.id = (id) 5003 tries = 0 5004 plumbing_response = None 5005 while True: 5006 t = None if deadline is None else deadline - time.time() 5007 try: 5008 plumbing_response = self.stub.Delete( 5009 req, 5010 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5011 req), 5012 timeout=t) 5013 except Exception as e: 5014 if self.parent.shouldRetry(tries, e, deadline): 5015 tries += 1 5016 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5017 continue 5018 raise plumbing.convert_error_to_porcelain(e) from e 5019 break 5020 5021 resp = models.PeeringGroupDeleteResponse() 5022 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5023 plumbing_response.meta) 5024 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5025 plumbing_response.rate_limit) 5026 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5028 def get(self, id, timeout=None): 5029 ''' 5030 Get reads one PeeringGroup by ID. It will load all its dependencies. 5031 ''' 5032 deadline = None if timeout is None else time.time() + timeout 5033 req = PeeringGroupGetRequest() 5034 if self.parent.snapshot_datetime is not None: 5035 req.meta.CopyFrom(GetRequestMetadata()) 5036 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5037 5038 req.id = (id) 5039 tries = 0 5040 plumbing_response = None 5041 while True: 5042 t = None if deadline is None else deadline - time.time() 5043 try: 5044 plumbing_response = self.stub.Get( 5045 req, 5046 metadata=self.parent.get_metadata('PeeringGroups.Get', 5047 req), 5048 timeout=t) 5049 except Exception as e: 5050 if self.parent.shouldRetry(tries, e, deadline): 5051 tries += 1 5052 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5053 continue 5054 raise plumbing.convert_error_to_porcelain(e) from e 5055 break 5056 5057 resp = models.PeeringGroupGetResponse() 5058 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5059 plumbing_response.meta) 5060 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5061 plumbing_response.peering_group) 5062 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5063 plumbing_response.rate_limit) 5064 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5066 def list(self, filter, *args, timeout=None): 5067 ''' 5068 List gets a list of Peering Groups. 5069 ''' 5070 deadline = None if timeout is None else time.time() + timeout 5071 req = PeeringGroupListRequest() 5072 req.meta.CopyFrom(ListRequestMetadata()) 5073 if self.parent.page_limit > 0: 5074 req.meta.limit = self.parent.page_limit 5075 if self.parent.snapshot_datetime is not None: 5076 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5077 5078 req.filter = plumbing.quote_filter_args(filter, *args) 5079 5080 def generator(svc, req): 5081 tries = 0 5082 while True: 5083 t = None if deadline is None else deadline - time.time() 5084 try: 5085 plumbing_response = svc.stub.List( 5086 req, 5087 metadata=svc.parent.get_metadata( 5088 'PeeringGroups.List', req), 5089 timeout=t) 5090 except Exception as e: 5091 if self.parent.shouldRetry(tries, e, deadline): 5092 tries += 1 5093 time.sleep( 5094 self.parent.exponentialBackoff(tries, deadline)) 5095 continue 5096 raise plumbing.convert_error_to_porcelain(e) from e 5097 tries = 0 5098 for plumbing_item in plumbing_response.peering_groups: 5099 yield plumbing.convert_peering_group_to_porcelain( 5100 plumbing_item) 5101 if plumbing_response.meta.next_cursor == '': 5102 break 5103 req.meta.cursor = plumbing_response.meta.next_cursor 5104 5105 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5108class Policies: 5109 ''' 5110 Policies are the collection of one or more statements that enforce fine-grained access 5111 control for the users of an organization. 5112 See `strongdm.models.Policy`. 5113 ''' 5114 def __init__(self, channel, client): 5115 self.parent = client 5116 self.stub = PoliciesStub(channel) 5117 5118 def create(self, policy, timeout=None): 5119 ''' 5120 Create creates a new Policy. 5121 ''' 5122 deadline = None if timeout is None else time.time() + timeout 5123 req = PolicyCreateRequest() 5124 5125 if policy is not None: 5126 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5127 tries = 0 5128 plumbing_response = None 5129 while True: 5130 t = None if deadline is None else deadline - time.time() 5131 try: 5132 plumbing_response = self.stub.Create( 5133 req, 5134 metadata=self.parent.get_metadata('Policies.Create', req), 5135 timeout=t) 5136 except Exception as e: 5137 if self.parent.shouldRetry(tries, e, deadline): 5138 tries += 1 5139 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5140 continue 5141 raise plumbing.convert_error_to_porcelain(e) from e 5142 break 5143 5144 resp = models.PolicyCreateResponse() 5145 resp.policy = plumbing.convert_policy_to_porcelain( 5146 plumbing_response.policy) 5147 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5148 plumbing_response.rate_limit) 5149 return resp 5150 5151 def delete(self, id, timeout=None): 5152 ''' 5153 Delete removes a Policy by ID. 5154 ''' 5155 deadline = None if timeout is None else time.time() + timeout 5156 req = PolicyDeleteRequest() 5157 5158 req.id = (id) 5159 tries = 0 5160 plumbing_response = None 5161 while True: 5162 t = None if deadline is None else deadline - time.time() 5163 try: 5164 plumbing_response = self.stub.Delete( 5165 req, 5166 metadata=self.parent.get_metadata('Policies.Delete', req), 5167 timeout=t) 5168 except Exception as e: 5169 if self.parent.shouldRetry(tries, e, deadline): 5170 tries += 1 5171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5172 continue 5173 raise plumbing.convert_error_to_porcelain(e) from e 5174 break 5175 5176 resp = models.PolicyDeleteResponse() 5177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5178 plumbing_response.rate_limit) 5179 return resp 5180 5181 def update(self, policy, timeout=None): 5182 ''' 5183 Update replaces all the fields of a Policy by ID. 5184 ''' 5185 deadline = None if timeout is None else time.time() + timeout 5186 req = PolicyUpdateRequest() 5187 5188 if policy is not None: 5189 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5190 tries = 0 5191 plumbing_response = None 5192 while True: 5193 t = None if deadline is None else deadline - time.time() 5194 try: 5195 plumbing_response = self.stub.Update( 5196 req, 5197 metadata=self.parent.get_metadata('Policies.Update', req), 5198 timeout=t) 5199 except Exception as e: 5200 if self.parent.shouldRetry(tries, e, deadline): 5201 tries += 1 5202 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5203 continue 5204 raise plumbing.convert_error_to_porcelain(e) from e 5205 break 5206 5207 resp = models.PolicyUpdateResponse() 5208 resp.policy = plumbing.convert_policy_to_porcelain( 5209 plumbing_response.policy) 5210 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5211 plumbing_response.rate_limit) 5212 return resp 5213 5214 def get(self, id, timeout=None): 5215 ''' 5216 Get reads one Policy by ID. 5217 ''' 5218 deadline = None if timeout is None else time.time() + timeout 5219 req = PolicyGetRequest() 5220 if self.parent.snapshot_datetime is not None: 5221 req.meta.CopyFrom(GetRequestMetadata()) 5222 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5223 5224 req.id = (id) 5225 tries = 0 5226 plumbing_response = None 5227 while True: 5228 t = None if deadline is None else deadline - time.time() 5229 try: 5230 plumbing_response = self.stub.Get( 5231 req, 5232 metadata=self.parent.get_metadata('Policies.Get', req), 5233 timeout=t) 5234 except Exception as e: 5235 if self.parent.shouldRetry(tries, e, deadline): 5236 tries += 1 5237 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5238 continue 5239 raise plumbing.convert_error_to_porcelain(e) from e 5240 break 5241 5242 resp = models.PolicyGetResponse() 5243 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5244 plumbing_response.meta) 5245 resp.policy = plumbing.convert_policy_to_porcelain( 5246 plumbing_response.policy) 5247 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5248 plumbing_response.rate_limit) 5249 return resp 5250 5251 def list(self, filter, *args, timeout=None): 5252 ''' 5253 List gets a list of Policy matching a given set of criteria 5254 ''' 5255 deadline = None if timeout is None else time.time() + timeout 5256 req = PolicyListRequest() 5257 req.meta.CopyFrom(ListRequestMetadata()) 5258 if self.parent.page_limit > 0: 5259 req.meta.limit = self.parent.page_limit 5260 if self.parent.snapshot_datetime is not None: 5261 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5262 5263 req.filter = plumbing.quote_filter_args(filter, *args) 5264 5265 def generator(svc, req): 5266 tries = 0 5267 while True: 5268 t = None if deadline is None else deadline - time.time() 5269 try: 5270 plumbing_response = svc.stub.List( 5271 req, 5272 metadata=svc.parent.get_metadata('Policies.List', req), 5273 timeout=t) 5274 except Exception as e: 5275 if self.parent.shouldRetry(tries, e, deadline): 5276 tries += 1 5277 time.sleep( 5278 self.parent.exponentialBackoff(tries, deadline)) 5279 continue 5280 raise plumbing.convert_error_to_porcelain(e) from e 5281 tries = 0 5282 for plumbing_item in plumbing_response.policies: 5283 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5284 if plumbing_response.meta.next_cursor == '': 5285 break 5286 req.meta.cursor = plumbing_response.meta.next_cursor 5287 5288 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)
5118 def create(self, policy, timeout=None): 5119 ''' 5120 Create creates a new Policy. 5121 ''' 5122 deadline = None if timeout is None else time.time() + timeout 5123 req = PolicyCreateRequest() 5124 5125 if policy is not None: 5126 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5127 tries = 0 5128 plumbing_response = None 5129 while True: 5130 t = None if deadline is None else deadline - time.time() 5131 try: 5132 plumbing_response = self.stub.Create( 5133 req, 5134 metadata=self.parent.get_metadata('Policies.Create', req), 5135 timeout=t) 5136 except Exception as e: 5137 if self.parent.shouldRetry(tries, e, deadline): 5138 tries += 1 5139 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5140 continue 5141 raise plumbing.convert_error_to_porcelain(e) from e 5142 break 5143 5144 resp = models.PolicyCreateResponse() 5145 resp.policy = plumbing.convert_policy_to_porcelain( 5146 plumbing_response.policy) 5147 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5148 plumbing_response.rate_limit) 5149 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5151 def delete(self, id, timeout=None): 5152 ''' 5153 Delete removes a Policy by ID. 5154 ''' 5155 deadline = None if timeout is None else time.time() + timeout 5156 req = PolicyDeleteRequest() 5157 5158 req.id = (id) 5159 tries = 0 5160 plumbing_response = None 5161 while True: 5162 t = None if deadline is None else deadline - time.time() 5163 try: 5164 plumbing_response = self.stub.Delete( 5165 req, 5166 metadata=self.parent.get_metadata('Policies.Delete', req), 5167 timeout=t) 5168 except Exception as e: 5169 if self.parent.shouldRetry(tries, e, deadline): 5170 tries += 1 5171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5172 continue 5173 raise plumbing.convert_error_to_porcelain(e) from e 5174 break 5175 5176 resp = models.PolicyDeleteResponse() 5177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5178 plumbing_response.rate_limit) 5179 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5181 def update(self, policy, timeout=None): 5182 ''' 5183 Update replaces all the fields of a Policy by ID. 5184 ''' 5185 deadline = None if timeout is None else time.time() + timeout 5186 req = PolicyUpdateRequest() 5187 5188 if policy is not None: 5189 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5190 tries = 0 5191 plumbing_response = None 5192 while True: 5193 t = None if deadline is None else deadline - time.time() 5194 try: 5195 plumbing_response = self.stub.Update( 5196 req, 5197 metadata=self.parent.get_metadata('Policies.Update', req), 5198 timeout=t) 5199 except Exception as e: 5200 if self.parent.shouldRetry(tries, e, deadline): 5201 tries += 1 5202 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5203 continue 5204 raise plumbing.convert_error_to_porcelain(e) from e 5205 break 5206 5207 resp = models.PolicyUpdateResponse() 5208 resp.policy = plumbing.convert_policy_to_porcelain( 5209 plumbing_response.policy) 5210 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5211 plumbing_response.rate_limit) 5212 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5214 def get(self, id, timeout=None): 5215 ''' 5216 Get reads one Policy by ID. 5217 ''' 5218 deadline = None if timeout is None else time.time() + timeout 5219 req = PolicyGetRequest() 5220 if self.parent.snapshot_datetime is not None: 5221 req.meta.CopyFrom(GetRequestMetadata()) 5222 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5223 5224 req.id = (id) 5225 tries = 0 5226 plumbing_response = None 5227 while True: 5228 t = None if deadline is None else deadline - time.time() 5229 try: 5230 plumbing_response = self.stub.Get( 5231 req, 5232 metadata=self.parent.get_metadata('Policies.Get', req), 5233 timeout=t) 5234 except Exception as e: 5235 if self.parent.shouldRetry(tries, e, deadline): 5236 tries += 1 5237 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5238 continue 5239 raise plumbing.convert_error_to_porcelain(e) from e 5240 break 5241 5242 resp = models.PolicyGetResponse() 5243 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5244 plumbing_response.meta) 5245 resp.policy = plumbing.convert_policy_to_porcelain( 5246 plumbing_response.policy) 5247 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5248 plumbing_response.rate_limit) 5249 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5251 def list(self, filter, *args, timeout=None): 5252 ''' 5253 List gets a list of Policy matching a given set of criteria 5254 ''' 5255 deadline = None if timeout is None else time.time() + timeout 5256 req = PolicyListRequest() 5257 req.meta.CopyFrom(ListRequestMetadata()) 5258 if self.parent.page_limit > 0: 5259 req.meta.limit = self.parent.page_limit 5260 if self.parent.snapshot_datetime is not None: 5261 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5262 5263 req.filter = plumbing.quote_filter_args(filter, *args) 5264 5265 def generator(svc, req): 5266 tries = 0 5267 while True: 5268 t = None if deadline is None else deadline - time.time() 5269 try: 5270 plumbing_response = svc.stub.List( 5271 req, 5272 metadata=svc.parent.get_metadata('Policies.List', req), 5273 timeout=t) 5274 except Exception as e: 5275 if self.parent.shouldRetry(tries, e, deadline): 5276 tries += 1 5277 time.sleep( 5278 self.parent.exponentialBackoff(tries, deadline)) 5279 continue 5280 raise plumbing.convert_error_to_porcelain(e) from e 5281 tries = 0 5282 for plumbing_item in plumbing_response.policies: 5283 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5284 if plumbing_response.meta.next_cursor == '': 5285 break 5286 req.meta.cursor = plumbing_response.meta.next_cursor 5287 5288 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5291class SnapshotPolicies: 5292 ''' 5293 SnapshotPolicies exposes the read only methods of the Policies 5294 service for historical queries. 5295 ''' 5296 def __init__(self, policies): 5297 self.policies = policies 5298 5299 def get(self, id, timeout=None): 5300 ''' 5301 Get reads one Policy by ID. 5302 ''' 5303 return self.policies.get(id, timeout=timeout) 5304 5305 def list(self, filter, *args, timeout=None): 5306 ''' 5307 List gets a list of Policy matching a given set of criteria 5308 ''' 5309 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5312class PoliciesHistory: 5313 ''' 5314 PoliciesHistory records all changes to the state of a Policy. 5315 See `strongdm.models.PolicyHistory`. 5316 ''' 5317 def __init__(self, channel, client): 5318 self.parent = client 5319 self.stub = PoliciesHistoryStub(channel) 5320 5321 def list(self, filter, *args, timeout=None): 5322 ''' 5323 List gets a list of PolicyHistory records matching a given set of criteria. 5324 ''' 5325 deadline = None if timeout is None else time.time() + timeout 5326 req = PoliciesHistoryListRequest() 5327 req.meta.CopyFrom(ListRequestMetadata()) 5328 if self.parent.page_limit > 0: 5329 req.meta.limit = self.parent.page_limit 5330 if self.parent.snapshot_datetime is not None: 5331 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5332 5333 req.filter = plumbing.quote_filter_args(filter, *args) 5334 5335 def generator(svc, req): 5336 tries = 0 5337 while True: 5338 t = None if deadline is None else deadline - time.time() 5339 try: 5340 plumbing_response = svc.stub.List( 5341 req, 5342 metadata=svc.parent.get_metadata( 5343 'PoliciesHistory.List', req), 5344 timeout=t) 5345 except Exception as e: 5346 if self.parent.shouldRetry(tries, e, deadline): 5347 tries += 1 5348 time.sleep( 5349 self.parent.exponentialBackoff(tries, deadline)) 5350 continue 5351 raise plumbing.convert_error_to_porcelain(e) from e 5352 tries = 0 5353 for plumbing_item in plumbing_response.history: 5354 yield plumbing.convert_policy_history_to_porcelain( 5355 plumbing_item) 5356 if plumbing_response.meta.next_cursor == '': 5357 break 5358 req.meta.cursor = plumbing_response.meta.next_cursor 5359 5360 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)
5321 def list(self, filter, *args, timeout=None): 5322 ''' 5323 List gets a list of PolicyHistory records matching a given set of criteria. 5324 ''' 5325 deadline = None if timeout is None else time.time() + timeout 5326 req = PoliciesHistoryListRequest() 5327 req.meta.CopyFrom(ListRequestMetadata()) 5328 if self.parent.page_limit > 0: 5329 req.meta.limit = self.parent.page_limit 5330 if self.parent.snapshot_datetime is not None: 5331 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5332 5333 req.filter = plumbing.quote_filter_args(filter, *args) 5334 5335 def generator(svc, req): 5336 tries = 0 5337 while True: 5338 t = None if deadline is None else deadline - time.time() 5339 try: 5340 plumbing_response = svc.stub.List( 5341 req, 5342 metadata=svc.parent.get_metadata( 5343 'PoliciesHistory.List', req), 5344 timeout=t) 5345 except Exception as e: 5346 if self.parent.shouldRetry(tries, e, deadline): 5347 tries += 1 5348 time.sleep( 5349 self.parent.exponentialBackoff(tries, deadline)) 5350 continue 5351 raise plumbing.convert_error_to_porcelain(e) from e 5352 tries = 0 5353 for plumbing_item in plumbing_response.history: 5354 yield plumbing.convert_policy_history_to_porcelain( 5355 plumbing_item) 5356 if plumbing_response.meta.next_cursor == '': 5357 break 5358 req.meta.cursor = plumbing_response.meta.next_cursor 5359 5360 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
5363class ProxyClusterKeys: 5364 ''' 5365 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5366 The proxies within a cluster share the same key. One cluster can have 5367 multiple keys in order to facilitate key rotation. 5368 See `strongdm.models.ProxyClusterKey`. 5369 ''' 5370 def __init__(self, channel, client): 5371 self.parent = client 5372 self.stub = ProxyClusterKeysStub(channel) 5373 5374 def create(self, proxy_cluster_key, timeout=None): 5375 ''' 5376 Create registers a new ProxyClusterKey. 5377 ''' 5378 deadline = None if timeout is None else time.time() + timeout 5379 req = ProxyClusterKeyCreateRequest() 5380 5381 if proxy_cluster_key is not None: 5382 req.proxy_cluster_key.CopyFrom( 5383 plumbing.convert_proxy_cluster_key_to_plumbing( 5384 proxy_cluster_key)) 5385 tries = 0 5386 plumbing_response = None 5387 while True: 5388 t = None if deadline is None else deadline - time.time() 5389 try: 5390 plumbing_response = self.stub.Create( 5391 req, 5392 metadata=self.parent.get_metadata( 5393 'ProxyClusterKeys.Create', req), 5394 timeout=t) 5395 except Exception as e: 5396 if self.parent.shouldRetry(tries, e, deadline): 5397 tries += 1 5398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5399 continue 5400 raise plumbing.convert_error_to_porcelain(e) from e 5401 break 5402 5403 resp = models.ProxyClusterKeyCreateResponse() 5404 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5405 plumbing_response.meta) 5406 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5407 plumbing_response.proxy_cluster_key) 5408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5409 plumbing_response.rate_limit) 5410 resp.secret_key = (plumbing_response.secret_key) 5411 return resp 5412 5413 def get(self, id, timeout=None): 5414 ''' 5415 Get reads one ProxyClusterKey by ID. 5416 ''' 5417 deadline = None if timeout is None else time.time() + timeout 5418 req = ProxyClusterKeyGetRequest() 5419 if self.parent.snapshot_datetime is not None: 5420 req.meta.CopyFrom(GetRequestMetadata()) 5421 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5422 5423 req.id = (id) 5424 tries = 0 5425 plumbing_response = None 5426 while True: 5427 t = None if deadline is None else deadline - time.time() 5428 try: 5429 plumbing_response = self.stub.Get( 5430 req, 5431 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5432 req), 5433 timeout=t) 5434 except Exception as e: 5435 if self.parent.shouldRetry(tries, e, deadline): 5436 tries += 1 5437 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5438 continue 5439 raise plumbing.convert_error_to_porcelain(e) from e 5440 break 5441 5442 resp = models.ProxyClusterKeyGetResponse() 5443 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5444 plumbing_response.meta) 5445 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5446 plumbing_response.proxy_cluster_key) 5447 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5448 plumbing_response.rate_limit) 5449 return resp 5450 5451 def delete(self, id, timeout=None): 5452 ''' 5453 Delete removes a ProxyClusterKey by ID. 5454 ''' 5455 deadline = None if timeout is None else time.time() + timeout 5456 req = ProxyClusterKeyDeleteRequest() 5457 5458 req.id = (id) 5459 tries = 0 5460 plumbing_response = None 5461 while True: 5462 t = None if deadline is None else deadline - time.time() 5463 try: 5464 plumbing_response = self.stub.Delete( 5465 req, 5466 metadata=self.parent.get_metadata( 5467 'ProxyClusterKeys.Delete', req), 5468 timeout=t) 5469 except Exception as e: 5470 if self.parent.shouldRetry(tries, e, deadline): 5471 tries += 1 5472 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5473 continue 5474 raise plumbing.convert_error_to_porcelain(e) from e 5475 break 5476 5477 resp = models.ProxyClusterKeyDeleteResponse() 5478 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5479 plumbing_response.meta) 5480 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5481 plumbing_response.rate_limit) 5482 return resp 5483 5484 def list(self, filter, *args, timeout=None): 5485 ''' 5486 List gets a list of ProxyClusterKeys matching a given set of criteria. 5487 ''' 5488 deadline = None if timeout is None else time.time() + timeout 5489 req = ProxyClusterKeyListRequest() 5490 req.meta.CopyFrom(ListRequestMetadata()) 5491 if self.parent.page_limit > 0: 5492 req.meta.limit = self.parent.page_limit 5493 if self.parent.snapshot_datetime is not None: 5494 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5495 5496 req.filter = plumbing.quote_filter_args(filter, *args) 5497 5498 def generator(svc, req): 5499 tries = 0 5500 while True: 5501 t = None if deadline is None else deadline - time.time() 5502 try: 5503 plumbing_response = svc.stub.List( 5504 req, 5505 metadata=svc.parent.get_metadata( 5506 'ProxyClusterKeys.List', req), 5507 timeout=t) 5508 except Exception as e: 5509 if self.parent.shouldRetry(tries, e, deadline): 5510 tries += 1 5511 time.sleep( 5512 self.parent.exponentialBackoff(tries, deadline)) 5513 continue 5514 raise plumbing.convert_error_to_porcelain(e) from e 5515 tries = 0 5516 for plumbing_item in plumbing_response.proxy_cluster_keys: 5517 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5518 plumbing_item) 5519 if plumbing_response.meta.next_cursor == '': 5520 break 5521 req.meta.cursor = plumbing_response.meta.next_cursor 5522 5523 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)
5374 def create(self, proxy_cluster_key, timeout=None): 5375 ''' 5376 Create registers a new ProxyClusterKey. 5377 ''' 5378 deadline = None if timeout is None else time.time() + timeout 5379 req = ProxyClusterKeyCreateRequest() 5380 5381 if proxy_cluster_key is not None: 5382 req.proxy_cluster_key.CopyFrom( 5383 plumbing.convert_proxy_cluster_key_to_plumbing( 5384 proxy_cluster_key)) 5385 tries = 0 5386 plumbing_response = None 5387 while True: 5388 t = None if deadline is None else deadline - time.time() 5389 try: 5390 plumbing_response = self.stub.Create( 5391 req, 5392 metadata=self.parent.get_metadata( 5393 'ProxyClusterKeys.Create', req), 5394 timeout=t) 5395 except Exception as e: 5396 if self.parent.shouldRetry(tries, e, deadline): 5397 tries += 1 5398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5399 continue 5400 raise plumbing.convert_error_to_porcelain(e) from e 5401 break 5402 5403 resp = models.ProxyClusterKeyCreateResponse() 5404 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5405 plumbing_response.meta) 5406 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5407 plumbing_response.proxy_cluster_key) 5408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5409 plumbing_response.rate_limit) 5410 resp.secret_key = (plumbing_response.secret_key) 5411 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
5413 def get(self, id, timeout=None): 5414 ''' 5415 Get reads one ProxyClusterKey by ID. 5416 ''' 5417 deadline = None if timeout is None else time.time() + timeout 5418 req = ProxyClusterKeyGetRequest() 5419 if self.parent.snapshot_datetime is not None: 5420 req.meta.CopyFrom(GetRequestMetadata()) 5421 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5422 5423 req.id = (id) 5424 tries = 0 5425 plumbing_response = None 5426 while True: 5427 t = None if deadline is None else deadline - time.time() 5428 try: 5429 plumbing_response = self.stub.Get( 5430 req, 5431 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5432 req), 5433 timeout=t) 5434 except Exception as e: 5435 if self.parent.shouldRetry(tries, e, deadline): 5436 tries += 1 5437 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5438 continue 5439 raise plumbing.convert_error_to_porcelain(e) from e 5440 break 5441 5442 resp = models.ProxyClusterKeyGetResponse() 5443 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5444 plumbing_response.meta) 5445 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5446 plumbing_response.proxy_cluster_key) 5447 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5448 plumbing_response.rate_limit) 5449 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
5451 def delete(self, id, timeout=None): 5452 ''' 5453 Delete removes a ProxyClusterKey by ID. 5454 ''' 5455 deadline = None if timeout is None else time.time() + timeout 5456 req = ProxyClusterKeyDeleteRequest() 5457 5458 req.id = (id) 5459 tries = 0 5460 plumbing_response = None 5461 while True: 5462 t = None if deadline is None else deadline - time.time() 5463 try: 5464 plumbing_response = self.stub.Delete( 5465 req, 5466 metadata=self.parent.get_metadata( 5467 'ProxyClusterKeys.Delete', req), 5468 timeout=t) 5469 except Exception as e: 5470 if self.parent.shouldRetry(tries, e, deadline): 5471 tries += 1 5472 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5473 continue 5474 raise plumbing.convert_error_to_porcelain(e) from e 5475 break 5476 5477 resp = models.ProxyClusterKeyDeleteResponse() 5478 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5479 plumbing_response.meta) 5480 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5481 plumbing_response.rate_limit) 5482 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5484 def list(self, filter, *args, timeout=None): 5485 ''' 5486 List gets a list of ProxyClusterKeys matching a given set of criteria. 5487 ''' 5488 deadline = None if timeout is None else time.time() + timeout 5489 req = ProxyClusterKeyListRequest() 5490 req.meta.CopyFrom(ListRequestMetadata()) 5491 if self.parent.page_limit > 0: 5492 req.meta.limit = self.parent.page_limit 5493 if self.parent.snapshot_datetime is not None: 5494 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5495 5496 req.filter = plumbing.quote_filter_args(filter, *args) 5497 5498 def generator(svc, req): 5499 tries = 0 5500 while True: 5501 t = None if deadline is None else deadline - time.time() 5502 try: 5503 plumbing_response = svc.stub.List( 5504 req, 5505 metadata=svc.parent.get_metadata( 5506 'ProxyClusterKeys.List', req), 5507 timeout=t) 5508 except Exception as e: 5509 if self.parent.shouldRetry(tries, e, deadline): 5510 tries += 1 5511 time.sleep( 5512 self.parent.exponentialBackoff(tries, deadline)) 5513 continue 5514 raise plumbing.convert_error_to_porcelain(e) from e 5515 tries = 0 5516 for plumbing_item in plumbing_response.proxy_cluster_keys: 5517 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5518 plumbing_item) 5519 if plumbing_response.meta.next_cursor == '': 5520 break 5521 req.meta.cursor = plumbing_response.meta.next_cursor 5522 5523 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
5526class SnapshotProxyClusterKeys: 5527 ''' 5528 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5529 service for historical queries. 5530 ''' 5531 def __init__(self, proxy_cluster_keys): 5532 self.proxy_cluster_keys = proxy_cluster_keys 5533 5534 def get(self, id, timeout=None): 5535 ''' 5536 Get reads one ProxyClusterKey by ID. 5537 ''' 5538 return self.proxy_cluster_keys.get(id, timeout=timeout) 5539 5540 def list(self, filter, *args, timeout=None): 5541 ''' 5542 List gets a list of ProxyClusterKeys matching a given set of criteria. 5543 ''' 5544 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)
5534 def get(self, id, timeout=None): 5535 ''' 5536 Get reads one ProxyClusterKey by ID. 5537 ''' 5538 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5540 def list(self, filter, *args, timeout=None): 5541 ''' 5542 List gets a list of ProxyClusterKeys matching a given set of criteria. 5543 ''' 5544 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
5547class Queries: 5548 ''' 5549 A Query is a record of a single client request to a resource, such as a SQL query. 5550 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5551 The Queries service is read-only. 5552 See `strongdm.models.Query`. 5553 ''' 5554 def __init__(self, channel, client): 5555 self.parent = client 5556 self.stub = QueriesStub(channel) 5557 5558 def list(self, filter, *args, timeout=None): 5559 ''' 5560 List gets a list of Queries matching a given set of criteria. 5561 ''' 5562 deadline = None if timeout is None else time.time() + timeout 5563 req = QueryListRequest() 5564 req.meta.CopyFrom(ListRequestMetadata()) 5565 if self.parent.page_limit > 0: 5566 req.meta.limit = self.parent.page_limit 5567 if self.parent.snapshot_datetime is not None: 5568 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5569 5570 req.filter = plumbing.quote_filter_args(filter, *args) 5571 5572 def generator(svc, req): 5573 tries = 0 5574 while True: 5575 t = None if deadline is None else deadline - time.time() 5576 try: 5577 plumbing_response = svc.stub.List( 5578 req, 5579 metadata=svc.parent.get_metadata('Queries.List', req), 5580 timeout=t) 5581 except Exception as e: 5582 if self.parent.shouldRetry(tries, e, deadline): 5583 tries += 1 5584 time.sleep( 5585 self.parent.exponentialBackoff(tries, deadline)) 5586 continue 5587 raise plumbing.convert_error_to_porcelain(e) from e 5588 tries = 0 5589 for plumbing_item in plumbing_response.queries: 5590 yield plumbing.convert_query_to_porcelain(plumbing_item) 5591 if plumbing_response.meta.next_cursor == '': 5592 break 5593 req.meta.cursor = plumbing_response.meta.next_cursor 5594 5595 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)
5558 def list(self, filter, *args, timeout=None): 5559 ''' 5560 List gets a list of Queries matching a given set of criteria. 5561 ''' 5562 deadline = None if timeout is None else time.time() + timeout 5563 req = QueryListRequest() 5564 req.meta.CopyFrom(ListRequestMetadata()) 5565 if self.parent.page_limit > 0: 5566 req.meta.limit = self.parent.page_limit 5567 if self.parent.snapshot_datetime is not None: 5568 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5569 5570 req.filter = plumbing.quote_filter_args(filter, *args) 5571 5572 def generator(svc, req): 5573 tries = 0 5574 while True: 5575 t = None if deadline is None else deadline - time.time() 5576 try: 5577 plumbing_response = svc.stub.List( 5578 req, 5579 metadata=svc.parent.get_metadata('Queries.List', req), 5580 timeout=t) 5581 except Exception as e: 5582 if self.parent.shouldRetry(tries, e, deadline): 5583 tries += 1 5584 time.sleep( 5585 self.parent.exponentialBackoff(tries, deadline)) 5586 continue 5587 raise plumbing.convert_error_to_porcelain(e) from e 5588 tries = 0 5589 for plumbing_item in plumbing_response.queries: 5590 yield plumbing.convert_query_to_porcelain(plumbing_item) 5591 if plumbing_response.meta.next_cursor == '': 5592 break 5593 req.meta.cursor = plumbing_response.meta.next_cursor 5594 5595 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
5598class RemoteIdentities: 5599 ''' 5600 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5601 See `strongdm.models.RemoteIdentity`. 5602 ''' 5603 def __init__(self, channel, client): 5604 self.parent = client 5605 self.stub = RemoteIdentitiesStub(channel) 5606 5607 def create(self, remote_identity, timeout=None): 5608 ''' 5609 Create registers a new RemoteIdentity. 5610 ''' 5611 deadline = None if timeout is None else time.time() + timeout 5612 req = RemoteIdentityCreateRequest() 5613 5614 if remote_identity is not None: 5615 req.remote_identity.CopyFrom( 5616 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5617 tries = 0 5618 plumbing_response = None 5619 while True: 5620 t = None if deadline is None else deadline - time.time() 5621 try: 5622 plumbing_response = self.stub.Create( 5623 req, 5624 metadata=self.parent.get_metadata( 5625 'RemoteIdentities.Create', req), 5626 timeout=t) 5627 except Exception as e: 5628 if self.parent.shouldRetry(tries, e, deadline): 5629 tries += 1 5630 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5631 continue 5632 raise plumbing.convert_error_to_porcelain(e) from e 5633 break 5634 5635 resp = models.RemoteIdentityCreateResponse() 5636 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5637 plumbing_response.meta) 5638 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5639 plumbing_response.rate_limit) 5640 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5641 plumbing_response.remote_identity) 5642 return resp 5643 5644 def get(self, id, timeout=None): 5645 ''' 5646 Get reads one RemoteIdentity by ID. 5647 ''' 5648 deadline = None if timeout is None else time.time() + timeout 5649 req = RemoteIdentityGetRequest() 5650 if self.parent.snapshot_datetime is not None: 5651 req.meta.CopyFrom(GetRequestMetadata()) 5652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5653 5654 req.id = (id) 5655 tries = 0 5656 plumbing_response = None 5657 while True: 5658 t = None if deadline is None else deadline - time.time() 5659 try: 5660 plumbing_response = self.stub.Get( 5661 req, 5662 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5663 req), 5664 timeout=t) 5665 except Exception as e: 5666 if self.parent.shouldRetry(tries, e, deadline): 5667 tries += 1 5668 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5669 continue 5670 raise plumbing.convert_error_to_porcelain(e) from e 5671 break 5672 5673 resp = models.RemoteIdentityGetResponse() 5674 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5675 plumbing_response.meta) 5676 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5677 plumbing_response.rate_limit) 5678 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5679 plumbing_response.remote_identity) 5680 return resp 5681 5682 def update(self, remote_identity, timeout=None): 5683 ''' 5684 Update replaces all the fields of a RemoteIdentity by ID. 5685 ''' 5686 deadline = None if timeout is None else time.time() + timeout 5687 req = RemoteIdentityUpdateRequest() 5688 5689 if remote_identity is not None: 5690 req.remote_identity.CopyFrom( 5691 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5692 tries = 0 5693 plumbing_response = None 5694 while True: 5695 t = None if deadline is None else deadline - time.time() 5696 try: 5697 plumbing_response = self.stub.Update( 5698 req, 5699 metadata=self.parent.get_metadata( 5700 'RemoteIdentities.Update', req), 5701 timeout=t) 5702 except Exception as e: 5703 if self.parent.shouldRetry(tries, e, deadline): 5704 tries += 1 5705 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5706 continue 5707 raise plumbing.convert_error_to_porcelain(e) from e 5708 break 5709 5710 resp = models.RemoteIdentityUpdateResponse() 5711 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5712 plumbing_response.meta) 5713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5714 plumbing_response.rate_limit) 5715 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5716 plumbing_response.remote_identity) 5717 return resp 5718 5719 def delete(self, id, timeout=None): 5720 ''' 5721 Delete removes a RemoteIdentity by ID. 5722 ''' 5723 deadline = None if timeout is None else time.time() + timeout 5724 req = RemoteIdentityDeleteRequest() 5725 5726 req.id = (id) 5727 tries = 0 5728 plumbing_response = None 5729 while True: 5730 t = None if deadline is None else deadline - time.time() 5731 try: 5732 plumbing_response = self.stub.Delete( 5733 req, 5734 metadata=self.parent.get_metadata( 5735 'RemoteIdentities.Delete', req), 5736 timeout=t) 5737 except Exception as e: 5738 if self.parent.shouldRetry(tries, e, deadline): 5739 tries += 1 5740 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5741 continue 5742 raise plumbing.convert_error_to_porcelain(e) from e 5743 break 5744 5745 resp = models.RemoteIdentityDeleteResponse() 5746 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5747 plumbing_response.meta) 5748 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5749 plumbing_response.rate_limit) 5750 return resp 5751 5752 def list(self, filter, *args, timeout=None): 5753 ''' 5754 List gets a list of RemoteIdentities matching a given set of criteria. 5755 ''' 5756 deadline = None if timeout is None else time.time() + timeout 5757 req = RemoteIdentityListRequest() 5758 req.meta.CopyFrom(ListRequestMetadata()) 5759 if self.parent.page_limit > 0: 5760 req.meta.limit = self.parent.page_limit 5761 if self.parent.snapshot_datetime is not None: 5762 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5763 5764 req.filter = plumbing.quote_filter_args(filter, *args) 5765 5766 def generator(svc, req): 5767 tries = 0 5768 while True: 5769 t = None if deadline is None else deadline - time.time() 5770 try: 5771 plumbing_response = svc.stub.List( 5772 req, 5773 metadata=svc.parent.get_metadata( 5774 'RemoteIdentities.List', req), 5775 timeout=t) 5776 except Exception as e: 5777 if self.parent.shouldRetry(tries, e, deadline): 5778 tries += 1 5779 time.sleep( 5780 self.parent.exponentialBackoff(tries, deadline)) 5781 continue 5782 raise plumbing.convert_error_to_porcelain(e) from e 5783 tries = 0 5784 for plumbing_item in plumbing_response.remote_identities: 5785 yield plumbing.convert_remote_identity_to_porcelain( 5786 plumbing_item) 5787 if plumbing_response.meta.next_cursor == '': 5788 break 5789 req.meta.cursor = plumbing_response.meta.next_cursor 5790 5791 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)
5607 def create(self, remote_identity, timeout=None): 5608 ''' 5609 Create registers a new RemoteIdentity. 5610 ''' 5611 deadline = None if timeout is None else time.time() + timeout 5612 req = RemoteIdentityCreateRequest() 5613 5614 if remote_identity is not None: 5615 req.remote_identity.CopyFrom( 5616 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5617 tries = 0 5618 plumbing_response = None 5619 while True: 5620 t = None if deadline is None else deadline - time.time() 5621 try: 5622 plumbing_response = self.stub.Create( 5623 req, 5624 metadata=self.parent.get_metadata( 5625 'RemoteIdentities.Create', req), 5626 timeout=t) 5627 except Exception as e: 5628 if self.parent.shouldRetry(tries, e, deadline): 5629 tries += 1 5630 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5631 continue 5632 raise plumbing.convert_error_to_porcelain(e) from e 5633 break 5634 5635 resp = models.RemoteIdentityCreateResponse() 5636 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5637 plumbing_response.meta) 5638 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5639 plumbing_response.rate_limit) 5640 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5641 plumbing_response.remote_identity) 5642 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
5644 def get(self, id, timeout=None): 5645 ''' 5646 Get reads one RemoteIdentity by ID. 5647 ''' 5648 deadline = None if timeout is None else time.time() + timeout 5649 req = RemoteIdentityGetRequest() 5650 if self.parent.snapshot_datetime is not None: 5651 req.meta.CopyFrom(GetRequestMetadata()) 5652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5653 5654 req.id = (id) 5655 tries = 0 5656 plumbing_response = None 5657 while True: 5658 t = None if deadline is None else deadline - time.time() 5659 try: 5660 plumbing_response = self.stub.Get( 5661 req, 5662 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5663 req), 5664 timeout=t) 5665 except Exception as e: 5666 if self.parent.shouldRetry(tries, e, deadline): 5667 tries += 1 5668 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5669 continue 5670 raise plumbing.convert_error_to_porcelain(e) from e 5671 break 5672 5673 resp = models.RemoteIdentityGetResponse() 5674 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5675 plumbing_response.meta) 5676 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5677 plumbing_response.rate_limit) 5678 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5679 plumbing_response.remote_identity) 5680 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
5682 def update(self, remote_identity, timeout=None): 5683 ''' 5684 Update replaces all the fields of a RemoteIdentity by ID. 5685 ''' 5686 deadline = None if timeout is None else time.time() + timeout 5687 req = RemoteIdentityUpdateRequest() 5688 5689 if remote_identity is not None: 5690 req.remote_identity.CopyFrom( 5691 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5692 tries = 0 5693 plumbing_response = None 5694 while True: 5695 t = None if deadline is None else deadline - time.time() 5696 try: 5697 plumbing_response = self.stub.Update( 5698 req, 5699 metadata=self.parent.get_metadata( 5700 'RemoteIdentities.Update', req), 5701 timeout=t) 5702 except Exception as e: 5703 if self.parent.shouldRetry(tries, e, deadline): 5704 tries += 1 5705 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5706 continue 5707 raise plumbing.convert_error_to_porcelain(e) from e 5708 break 5709 5710 resp = models.RemoteIdentityUpdateResponse() 5711 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5712 plumbing_response.meta) 5713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5714 plumbing_response.rate_limit) 5715 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5716 plumbing_response.remote_identity) 5717 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
5719 def delete(self, id, timeout=None): 5720 ''' 5721 Delete removes a RemoteIdentity by ID. 5722 ''' 5723 deadline = None if timeout is None else time.time() + timeout 5724 req = RemoteIdentityDeleteRequest() 5725 5726 req.id = (id) 5727 tries = 0 5728 plumbing_response = None 5729 while True: 5730 t = None if deadline is None else deadline - time.time() 5731 try: 5732 plumbing_response = self.stub.Delete( 5733 req, 5734 metadata=self.parent.get_metadata( 5735 'RemoteIdentities.Delete', req), 5736 timeout=t) 5737 except Exception as e: 5738 if self.parent.shouldRetry(tries, e, deadline): 5739 tries += 1 5740 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5741 continue 5742 raise plumbing.convert_error_to_porcelain(e) from e 5743 break 5744 5745 resp = models.RemoteIdentityDeleteResponse() 5746 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5747 plumbing_response.meta) 5748 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5749 plumbing_response.rate_limit) 5750 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
5752 def list(self, filter, *args, timeout=None): 5753 ''' 5754 List gets a list of RemoteIdentities matching a given set of criteria. 5755 ''' 5756 deadline = None if timeout is None else time.time() + timeout 5757 req = RemoteIdentityListRequest() 5758 req.meta.CopyFrom(ListRequestMetadata()) 5759 if self.parent.page_limit > 0: 5760 req.meta.limit = self.parent.page_limit 5761 if self.parent.snapshot_datetime is not None: 5762 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5763 5764 req.filter = plumbing.quote_filter_args(filter, *args) 5765 5766 def generator(svc, req): 5767 tries = 0 5768 while True: 5769 t = None if deadline is None else deadline - time.time() 5770 try: 5771 plumbing_response = svc.stub.List( 5772 req, 5773 metadata=svc.parent.get_metadata( 5774 'RemoteIdentities.List', req), 5775 timeout=t) 5776 except Exception as e: 5777 if self.parent.shouldRetry(tries, e, deadline): 5778 tries += 1 5779 time.sleep( 5780 self.parent.exponentialBackoff(tries, deadline)) 5781 continue 5782 raise plumbing.convert_error_to_porcelain(e) from e 5783 tries = 0 5784 for plumbing_item in plumbing_response.remote_identities: 5785 yield plumbing.convert_remote_identity_to_porcelain( 5786 plumbing_item) 5787 if plumbing_response.meta.next_cursor == '': 5788 break 5789 req.meta.cursor = plumbing_response.meta.next_cursor 5790 5791 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
5794class SnapshotRemoteIdentities: 5795 ''' 5796 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5797 service for historical queries. 5798 ''' 5799 def __init__(self, remote_identities): 5800 self.remote_identities = remote_identities 5801 5802 def get(self, id, timeout=None): 5803 ''' 5804 Get reads one RemoteIdentity by ID. 5805 ''' 5806 return self.remote_identities.get(id, timeout=timeout) 5807 5808 def list(self, filter, *args, timeout=None): 5809 ''' 5810 List gets a list of RemoteIdentities matching a given set of criteria. 5811 ''' 5812 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)
5802 def get(self, id, timeout=None): 5803 ''' 5804 Get reads one RemoteIdentity by ID. 5805 ''' 5806 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
5808 def list(self, filter, *args, timeout=None): 5809 ''' 5810 List gets a list of RemoteIdentities matching a given set of criteria. 5811 ''' 5812 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
5815class RemoteIdentitiesHistory: 5816 ''' 5817 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5818 See `strongdm.models.RemoteIdentityHistory`. 5819 ''' 5820 def __init__(self, channel, client): 5821 self.parent = client 5822 self.stub = RemoteIdentitiesHistoryStub(channel) 5823 5824 def list(self, filter, *args, timeout=None): 5825 ''' 5826 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5827 ''' 5828 deadline = None if timeout is None else time.time() + timeout 5829 req = RemoteIdentityHistoryListRequest() 5830 req.meta.CopyFrom(ListRequestMetadata()) 5831 if self.parent.page_limit > 0: 5832 req.meta.limit = self.parent.page_limit 5833 if self.parent.snapshot_datetime is not None: 5834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5835 5836 req.filter = plumbing.quote_filter_args(filter, *args) 5837 5838 def generator(svc, req): 5839 tries = 0 5840 while True: 5841 t = None if deadline is None else deadline - time.time() 5842 try: 5843 plumbing_response = svc.stub.List( 5844 req, 5845 metadata=svc.parent.get_metadata( 5846 'RemoteIdentitiesHistory.List', req), 5847 timeout=t) 5848 except Exception as e: 5849 if self.parent.shouldRetry(tries, e, deadline): 5850 tries += 1 5851 time.sleep( 5852 self.parent.exponentialBackoff(tries, deadline)) 5853 continue 5854 raise plumbing.convert_error_to_porcelain(e) from e 5855 tries = 0 5856 for plumbing_item in plumbing_response.history: 5857 yield plumbing.convert_remote_identity_history_to_porcelain( 5858 plumbing_item) 5859 if plumbing_response.meta.next_cursor == '': 5860 break 5861 req.meta.cursor = plumbing_response.meta.next_cursor 5862 5863 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)
5824 def list(self, filter, *args, timeout=None): 5825 ''' 5826 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5827 ''' 5828 deadline = None if timeout is None else time.time() + timeout 5829 req = RemoteIdentityHistoryListRequest() 5830 req.meta.CopyFrom(ListRequestMetadata()) 5831 if self.parent.page_limit > 0: 5832 req.meta.limit = self.parent.page_limit 5833 if self.parent.snapshot_datetime is not None: 5834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5835 5836 req.filter = plumbing.quote_filter_args(filter, *args) 5837 5838 def generator(svc, req): 5839 tries = 0 5840 while True: 5841 t = None if deadline is None else deadline - time.time() 5842 try: 5843 plumbing_response = svc.stub.List( 5844 req, 5845 metadata=svc.parent.get_metadata( 5846 'RemoteIdentitiesHistory.List', req), 5847 timeout=t) 5848 except Exception as e: 5849 if self.parent.shouldRetry(tries, e, deadline): 5850 tries += 1 5851 time.sleep( 5852 self.parent.exponentialBackoff(tries, deadline)) 5853 continue 5854 raise plumbing.convert_error_to_porcelain(e) from e 5855 tries = 0 5856 for plumbing_item in plumbing_response.history: 5857 yield plumbing.convert_remote_identity_history_to_porcelain( 5858 plumbing_item) 5859 if plumbing_response.meta.next_cursor == '': 5860 break 5861 req.meta.cursor = plumbing_response.meta.next_cursor 5862 5863 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
5866class RemoteIdentityGroups: 5867 ''' 5868 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5869 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5870 See `strongdm.models.RemoteIdentityGroup`. 5871 ''' 5872 def __init__(self, channel, client): 5873 self.parent = client 5874 self.stub = RemoteIdentityGroupsStub(channel) 5875 5876 def get(self, id, timeout=None): 5877 ''' 5878 Get reads one RemoteIdentityGroup by ID. 5879 ''' 5880 deadline = None if timeout is None else time.time() + timeout 5881 req = RemoteIdentityGroupGetRequest() 5882 if self.parent.snapshot_datetime is not None: 5883 req.meta.CopyFrom(GetRequestMetadata()) 5884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5885 5886 req.id = (id) 5887 tries = 0 5888 plumbing_response = None 5889 while True: 5890 t = None if deadline is None else deadline - time.time() 5891 try: 5892 plumbing_response = self.stub.Get( 5893 req, 5894 metadata=self.parent.get_metadata( 5895 'RemoteIdentityGroups.Get', req), 5896 timeout=t) 5897 except Exception as e: 5898 if self.parent.shouldRetry(tries, e, deadline): 5899 tries += 1 5900 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5901 continue 5902 raise plumbing.convert_error_to_porcelain(e) from e 5903 break 5904 5905 resp = models.RemoteIdentityGroupGetResponse() 5906 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5907 plumbing_response.meta) 5908 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5909 plumbing_response.rate_limit) 5910 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5911 plumbing_response.remote_identity_group) 5912 return resp 5913 5914 def list(self, filter, *args, timeout=None): 5915 ''' 5916 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5917 ''' 5918 deadline = None if timeout is None else time.time() + timeout 5919 req = RemoteIdentityGroupListRequest() 5920 req.meta.CopyFrom(ListRequestMetadata()) 5921 if self.parent.page_limit > 0: 5922 req.meta.limit = self.parent.page_limit 5923 if self.parent.snapshot_datetime is not None: 5924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5925 5926 req.filter = plumbing.quote_filter_args(filter, *args) 5927 5928 def generator(svc, req): 5929 tries = 0 5930 while True: 5931 t = None if deadline is None else deadline - time.time() 5932 try: 5933 plumbing_response = svc.stub.List( 5934 req, 5935 metadata=svc.parent.get_metadata( 5936 'RemoteIdentityGroups.List', req), 5937 timeout=t) 5938 except Exception as e: 5939 if self.parent.shouldRetry(tries, e, deadline): 5940 tries += 1 5941 time.sleep( 5942 self.parent.exponentialBackoff(tries, deadline)) 5943 continue 5944 raise plumbing.convert_error_to_porcelain(e) from e 5945 tries = 0 5946 for plumbing_item in plumbing_response.remote_identity_groups: 5947 yield plumbing.convert_remote_identity_group_to_porcelain( 5948 plumbing_item) 5949 if plumbing_response.meta.next_cursor == '': 5950 break 5951 req.meta.cursor = plumbing_response.meta.next_cursor 5952 5953 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)
5876 def get(self, id, timeout=None): 5877 ''' 5878 Get reads one RemoteIdentityGroup by ID. 5879 ''' 5880 deadline = None if timeout is None else time.time() + timeout 5881 req = RemoteIdentityGroupGetRequest() 5882 if self.parent.snapshot_datetime is not None: 5883 req.meta.CopyFrom(GetRequestMetadata()) 5884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5885 5886 req.id = (id) 5887 tries = 0 5888 plumbing_response = None 5889 while True: 5890 t = None if deadline is None else deadline - time.time() 5891 try: 5892 plumbing_response = self.stub.Get( 5893 req, 5894 metadata=self.parent.get_metadata( 5895 'RemoteIdentityGroups.Get', req), 5896 timeout=t) 5897 except Exception as e: 5898 if self.parent.shouldRetry(tries, e, deadline): 5899 tries += 1 5900 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5901 continue 5902 raise plumbing.convert_error_to_porcelain(e) from e 5903 break 5904 5905 resp = models.RemoteIdentityGroupGetResponse() 5906 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5907 plumbing_response.meta) 5908 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5909 plumbing_response.rate_limit) 5910 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5911 plumbing_response.remote_identity_group) 5912 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
5914 def list(self, filter, *args, timeout=None): 5915 ''' 5916 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5917 ''' 5918 deadline = None if timeout is None else time.time() + timeout 5919 req = RemoteIdentityGroupListRequest() 5920 req.meta.CopyFrom(ListRequestMetadata()) 5921 if self.parent.page_limit > 0: 5922 req.meta.limit = self.parent.page_limit 5923 if self.parent.snapshot_datetime is not None: 5924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5925 5926 req.filter = plumbing.quote_filter_args(filter, *args) 5927 5928 def generator(svc, req): 5929 tries = 0 5930 while True: 5931 t = None if deadline is None else deadline - time.time() 5932 try: 5933 plumbing_response = svc.stub.List( 5934 req, 5935 metadata=svc.parent.get_metadata( 5936 'RemoteIdentityGroups.List', req), 5937 timeout=t) 5938 except Exception as e: 5939 if self.parent.shouldRetry(tries, e, deadline): 5940 tries += 1 5941 time.sleep( 5942 self.parent.exponentialBackoff(tries, deadline)) 5943 continue 5944 raise plumbing.convert_error_to_porcelain(e) from e 5945 tries = 0 5946 for plumbing_item in plumbing_response.remote_identity_groups: 5947 yield plumbing.convert_remote_identity_group_to_porcelain( 5948 plumbing_item) 5949 if plumbing_response.meta.next_cursor == '': 5950 break 5951 req.meta.cursor = plumbing_response.meta.next_cursor 5952 5953 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
5956class SnapshotRemoteIdentityGroups: 5957 ''' 5958 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5959 service for historical queries. 5960 ''' 5961 def __init__(self, remote_identity_groups): 5962 self.remote_identity_groups = remote_identity_groups 5963 5964 def get(self, id, timeout=None): 5965 ''' 5966 Get reads one RemoteIdentityGroup by ID. 5967 ''' 5968 return self.remote_identity_groups.get(id, timeout=timeout) 5969 5970 def list(self, filter, *args, timeout=None): 5971 ''' 5972 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5973 ''' 5974 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)
5964 def get(self, id, timeout=None): 5965 ''' 5966 Get reads one RemoteIdentityGroup by ID. 5967 ''' 5968 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
5970 def list(self, filter, *args, timeout=None): 5971 ''' 5972 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5973 ''' 5974 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
5977class RemoteIdentityGroupsHistory: 5978 ''' 5979 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 5980 See `strongdm.models.RemoteIdentityGroupHistory`. 5981 ''' 5982 def __init__(self, channel, client): 5983 self.parent = client 5984 self.stub = RemoteIdentityGroupsHistoryStub(channel) 5985 5986 def list(self, filter, *args, timeout=None): 5987 ''' 5988 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5989 ''' 5990 deadline = None if timeout is None else time.time() + timeout 5991 req = RemoteIdentityGroupHistoryListRequest() 5992 req.meta.CopyFrom(ListRequestMetadata()) 5993 if self.parent.page_limit > 0: 5994 req.meta.limit = self.parent.page_limit 5995 if self.parent.snapshot_datetime is not None: 5996 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5997 5998 req.filter = plumbing.quote_filter_args(filter, *args) 5999 6000 def generator(svc, req): 6001 tries = 0 6002 while True: 6003 t = None if deadline is None else deadline - time.time() 6004 try: 6005 plumbing_response = svc.stub.List( 6006 req, 6007 metadata=svc.parent.get_metadata( 6008 'RemoteIdentityGroupsHistory.List', req), 6009 timeout=t) 6010 except Exception as e: 6011 if self.parent.shouldRetry(tries, e, deadline): 6012 tries += 1 6013 time.sleep( 6014 self.parent.exponentialBackoff(tries, deadline)) 6015 continue 6016 raise plumbing.convert_error_to_porcelain(e) from e 6017 tries = 0 6018 for plumbing_item in plumbing_response.history: 6019 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6020 plumbing_item) 6021 if plumbing_response.meta.next_cursor == '': 6022 break 6023 req.meta.cursor = plumbing_response.meta.next_cursor 6024 6025 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)
5986 def list(self, filter, *args, timeout=None): 5987 ''' 5988 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5989 ''' 5990 deadline = None if timeout is None else time.time() + timeout 5991 req = RemoteIdentityGroupHistoryListRequest() 5992 req.meta.CopyFrom(ListRequestMetadata()) 5993 if self.parent.page_limit > 0: 5994 req.meta.limit = self.parent.page_limit 5995 if self.parent.snapshot_datetime is not None: 5996 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5997 5998 req.filter = plumbing.quote_filter_args(filter, *args) 5999 6000 def generator(svc, req): 6001 tries = 0 6002 while True: 6003 t = None if deadline is None else deadline - time.time() 6004 try: 6005 plumbing_response = svc.stub.List( 6006 req, 6007 metadata=svc.parent.get_metadata( 6008 'RemoteIdentityGroupsHistory.List', req), 6009 timeout=t) 6010 except Exception as e: 6011 if self.parent.shouldRetry(tries, e, deadline): 6012 tries += 1 6013 time.sleep( 6014 self.parent.exponentialBackoff(tries, deadline)) 6015 continue 6016 raise plumbing.convert_error_to_porcelain(e) from e 6017 tries = 0 6018 for plumbing_item in plumbing_response.history: 6019 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6020 plumbing_item) 6021 if plumbing_response.meta.next_cursor == '': 6022 break 6023 req.meta.cursor = plumbing_response.meta.next_cursor 6024 6025 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6028class Replays: 6029 ''' 6030 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6031 (otherwise referred to as a query). The Replays service is read-only. 6032 See `strongdm.models.ReplayChunk`. 6033 ''' 6034 def __init__(self, channel, client): 6035 self.parent = client 6036 self.stub = ReplaysStub(channel) 6037 6038 def list(self, filter, *args, timeout=None): 6039 ''' 6040 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6041 ''' 6042 deadline = None if timeout is None else time.time() + timeout 6043 req = ReplayListRequest() 6044 req.meta.CopyFrom(ListRequestMetadata()) 6045 if self.parent.page_limit > 0: 6046 req.meta.limit = self.parent.page_limit 6047 if self.parent.snapshot_datetime is not None: 6048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6049 6050 req.filter = plumbing.quote_filter_args(filter, *args) 6051 6052 def generator(svc, req): 6053 tries = 0 6054 while True: 6055 t = None if deadline is None else deadline - time.time() 6056 try: 6057 plumbing_response = svc.stub.List( 6058 req, 6059 metadata=svc.parent.get_metadata('Replays.List', req), 6060 timeout=t) 6061 except Exception as e: 6062 if self.parent.shouldRetry(tries, e, deadline): 6063 tries += 1 6064 time.sleep( 6065 self.parent.exponentialBackoff(tries, deadline)) 6066 continue 6067 raise plumbing.convert_error_to_porcelain(e) from e 6068 tries = 0 6069 for plumbing_item in plumbing_response.chunks: 6070 yield plumbing.convert_replay_chunk_to_porcelain( 6071 plumbing_item) 6072 if plumbing_response.meta.next_cursor == '': 6073 break 6074 req.meta.cursor = plumbing_response.meta.next_cursor 6075 6076 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)
6038 def list(self, filter, *args, timeout=None): 6039 ''' 6040 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6041 ''' 6042 deadline = None if timeout is None else time.time() + timeout 6043 req = ReplayListRequest() 6044 req.meta.CopyFrom(ListRequestMetadata()) 6045 if self.parent.page_limit > 0: 6046 req.meta.limit = self.parent.page_limit 6047 if self.parent.snapshot_datetime is not None: 6048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6049 6050 req.filter = plumbing.quote_filter_args(filter, *args) 6051 6052 def generator(svc, req): 6053 tries = 0 6054 while True: 6055 t = None if deadline is None else deadline - time.time() 6056 try: 6057 plumbing_response = svc.stub.List( 6058 req, 6059 metadata=svc.parent.get_metadata('Replays.List', req), 6060 timeout=t) 6061 except Exception as e: 6062 if self.parent.shouldRetry(tries, e, deadline): 6063 tries += 1 6064 time.sleep( 6065 self.parent.exponentialBackoff(tries, deadline)) 6066 continue 6067 raise plumbing.convert_error_to_porcelain(e) from e 6068 tries = 0 6069 for plumbing_item in plumbing_response.chunks: 6070 yield plumbing.convert_replay_chunk_to_porcelain( 6071 plumbing_item) 6072 if plumbing_response.meta.next_cursor == '': 6073 break 6074 req.meta.cursor = plumbing_response.meta.next_cursor 6075 6076 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
6079class Resources: 6080 ''' 6081 Resources are databases, servers, clusters, websites, or clouds that strongDM 6082 delegates access to. 6083 See: 6084 `strongdm.models.Aerospike` 6085 `strongdm.models.AKS` 6086 `strongdm.models.AKSBasicAuth` 6087 `strongdm.models.AKSServiceAccount` 6088 `strongdm.models.AKSServiceAccountUserImpersonation` 6089 `strongdm.models.AKSUserImpersonation` 6090 `strongdm.models.AmazonEKS` 6091 `strongdm.models.AmazonEKSInstanceProfile` 6092 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6093 `strongdm.models.AmazonEKSUserImpersonation` 6094 `strongdm.models.AmazonES` 6095 `strongdm.models.AmazonESIAM` 6096 `strongdm.models.AmazonMQAMQP091` 6097 `strongdm.models.AMQP` 6098 `strongdm.models.Athena` 6099 `strongdm.models.AthenaIAM` 6100 `strongdm.models.AuroraMysql` 6101 `strongdm.models.AuroraMysqlIAM` 6102 `strongdm.models.AuroraPostgres` 6103 `strongdm.models.AuroraPostgresIAM` 6104 `strongdm.models.AWS` 6105 `strongdm.models.AWSConsole` 6106 `strongdm.models.AWSConsoleStaticKeyPair` 6107 `strongdm.models.AWSInstanceProfile` 6108 `strongdm.models.Azure` 6109 `strongdm.models.AzureCertificate` 6110 `strongdm.models.AzureMysql` 6111 `strongdm.models.AzureMysqlManagedIdentity` 6112 `strongdm.models.AzurePostgres` 6113 `strongdm.models.AzurePostgresManagedIdentity` 6114 `strongdm.models.BigQuery` 6115 `strongdm.models.Cassandra` 6116 `strongdm.models.Citus` 6117 `strongdm.models.ClickHouseHTTP` 6118 `strongdm.models.ClickHouseMySQL` 6119 `strongdm.models.ClickHouseTCP` 6120 `strongdm.models.Clustrix` 6121 `strongdm.models.Cockroach` 6122 `strongdm.models.CouchbaseDatabase` 6123 `strongdm.models.CouchbaseWebUI` 6124 `strongdm.models.DB2I` 6125 `strongdm.models.DB2LUW` 6126 `strongdm.models.DocumentDBHost` 6127 `strongdm.models.DocumentDBHostIAM` 6128 `strongdm.models.DocumentDBReplicaSet` 6129 `strongdm.models.DocumentDBReplicaSetIAM` 6130 `strongdm.models.Druid` 6131 `strongdm.models.DynamoDB` 6132 `strongdm.models.DynamoDBIAM` 6133 `strongdm.models.Elastic` 6134 `strongdm.models.ElasticacheRedis` 6135 `strongdm.models.EntraID` 6136 `strongdm.models.GCP` 6137 `strongdm.models.GCPConsole` 6138 `strongdm.models.GCPWIF` 6139 `strongdm.models.GoogleGKE` 6140 `strongdm.models.GoogleGKEUserImpersonation` 6141 `strongdm.models.Greenplum` 6142 `strongdm.models.HTTPAuth` 6143 `strongdm.models.HTTPBasicAuth` 6144 `strongdm.models.HTTPNoAuth` 6145 `strongdm.models.Kubernetes` 6146 `strongdm.models.KubernetesBasicAuth` 6147 `strongdm.models.KubernetesPodIdentity` 6148 `strongdm.models.KubernetesServiceAccount` 6149 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6150 `strongdm.models.KubernetesUserImpersonation` 6151 `strongdm.models.Maria` 6152 `strongdm.models.MCP` 6153 `strongdm.models.Memcached` 6154 `strongdm.models.Memsql` 6155 `strongdm.models.MongoHost` 6156 `strongdm.models.MongoLegacyHost` 6157 `strongdm.models.MongoLegacyReplicaset` 6158 `strongdm.models.MongoReplicaSet` 6159 `strongdm.models.MongoShardedCluster` 6160 `strongdm.models.MTLSMysql` 6161 `strongdm.models.MTLSPostgres` 6162 `strongdm.models.Mysql` 6163 `strongdm.models.Neptune` 6164 `strongdm.models.NeptuneIAM` 6165 `strongdm.models.Oracle` 6166 `strongdm.models.OracleNNE` 6167 `strongdm.models.Postgres` 6168 `strongdm.models.Presto` 6169 `strongdm.models.RabbitMQAMQP091` 6170 `strongdm.models.RawTCP` 6171 `strongdm.models.RDP` 6172 `strongdm.models.RDPCert` 6173 `strongdm.models.RDSPostgresIAM` 6174 `strongdm.models.Redis` 6175 `strongdm.models.RedisCluster` 6176 `strongdm.models.Redshift` 6177 `strongdm.models.RedshiftIAM` 6178 `strongdm.models.RedshiftServerlessIAM` 6179 `strongdm.models.SingleStore` 6180 `strongdm.models.Snowflake` 6181 `strongdm.models.Snowsight` 6182 `strongdm.models.SQLServer` 6183 `strongdm.models.SQLServerAzureAD` 6184 `strongdm.models.SQLServerKerberosAD` 6185 `strongdm.models.SSH` 6186 `strongdm.models.SSHCert` 6187 `strongdm.models.SSHCustomerKey` 6188 `strongdm.models.SSHPassword` 6189 `strongdm.models.Sybase` 6190 `strongdm.models.SybaseIQ` 6191 `strongdm.models.Teradata` 6192 `strongdm.models.Trino` 6193 `strongdm.models.Vertica` 6194 ''' 6195 def __init__(self, channel, client): 6196 self.parent = client 6197 self.stub = ResourcesStub(channel) 6198 6199 def enumerate_tags(self, filter, *args, timeout=None): 6200 ''' 6201 EnumerateTags gets a list of the filter matching tags. 6202 ''' 6203 deadline = None if timeout is None else time.time() + timeout 6204 req = EnumerateTagsRequest() 6205 req.meta.CopyFrom(ListRequestMetadata()) 6206 if self.parent.page_limit > 0: 6207 req.meta.limit = self.parent.page_limit 6208 if self.parent.snapshot_datetime is not None: 6209 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6210 6211 req.filter = plumbing.quote_filter_args(filter, *args) 6212 6213 def generator(svc, req): 6214 tries = 0 6215 while True: 6216 t = None if deadline is None else deadline - time.time() 6217 try: 6218 plumbing_response = svc.stub.EnumerateTags( 6219 req, 6220 metadata=svc.parent.get_metadata( 6221 'Resources.EnumerateTags', req), 6222 timeout=t) 6223 except Exception as e: 6224 if self.parent.shouldRetry(tries, e, deadline): 6225 tries += 1 6226 time.sleep( 6227 self.parent.exponentialBackoff(tries, deadline)) 6228 continue 6229 raise plumbing.convert_error_to_porcelain(e) from e 6230 tries = 0 6231 for plumbing_item in plumbing_response.matches: 6232 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6233 if plumbing_response.meta.next_cursor == '': 6234 break 6235 req.meta.cursor = plumbing_response.meta.next_cursor 6236 6237 return generator(self, req) 6238 6239 def create(self, resource, timeout=None): 6240 ''' 6241 Create registers a new Resource. 6242 ''' 6243 deadline = None if timeout is None else time.time() + timeout 6244 req = ResourceCreateRequest() 6245 6246 if resource is not None: 6247 req.resource.CopyFrom( 6248 plumbing.convert_resource_to_plumbing(resource)) 6249 tries = 0 6250 plumbing_response = None 6251 while True: 6252 t = None if deadline is None else deadline - time.time() 6253 try: 6254 plumbing_response = self.stub.Create( 6255 req, 6256 metadata=self.parent.get_metadata('Resources.Create', req), 6257 timeout=t) 6258 except Exception as e: 6259 if self.parent.shouldRetry(tries, e, deadline): 6260 tries += 1 6261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6262 continue 6263 raise plumbing.convert_error_to_porcelain(e) from e 6264 break 6265 6266 resp = models.ResourceCreateResponse() 6267 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6268 plumbing_response.meta) 6269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6270 plumbing_response.rate_limit) 6271 resp.resource = plumbing.convert_resource_to_porcelain( 6272 plumbing_response.resource) 6273 return resp 6274 6275 def get(self, id, timeout=None): 6276 ''' 6277 Get reads one Resource by ID. 6278 ''' 6279 deadline = None if timeout is None else time.time() + timeout 6280 req = ResourceGetRequest() 6281 if self.parent.snapshot_datetime is not None: 6282 req.meta.CopyFrom(GetRequestMetadata()) 6283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6284 6285 req.id = (id) 6286 tries = 0 6287 plumbing_response = None 6288 while True: 6289 t = None if deadline is None else deadline - time.time() 6290 try: 6291 plumbing_response = self.stub.Get( 6292 req, 6293 metadata=self.parent.get_metadata('Resources.Get', req), 6294 timeout=t) 6295 except Exception as e: 6296 if self.parent.shouldRetry(tries, e, deadline): 6297 tries += 1 6298 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6299 continue 6300 raise plumbing.convert_error_to_porcelain(e) from e 6301 break 6302 6303 resp = models.ResourceGetResponse() 6304 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6305 plumbing_response.meta) 6306 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6307 plumbing_response.rate_limit) 6308 resp.resource = plumbing.convert_resource_to_porcelain( 6309 plumbing_response.resource) 6310 return resp 6311 6312 def update(self, resource, timeout=None): 6313 ''' 6314 Update replaces all the fields of a Resource by ID. 6315 ''' 6316 deadline = None if timeout is None else time.time() + timeout 6317 req = ResourceUpdateRequest() 6318 6319 if resource is not None: 6320 req.resource.CopyFrom( 6321 plumbing.convert_resource_to_plumbing(resource)) 6322 tries = 0 6323 plumbing_response = None 6324 while True: 6325 t = None if deadline is None else deadline - time.time() 6326 try: 6327 plumbing_response = self.stub.Update( 6328 req, 6329 metadata=self.parent.get_metadata('Resources.Update', req), 6330 timeout=t) 6331 except Exception as e: 6332 if self.parent.shouldRetry(tries, e, deadline): 6333 tries += 1 6334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6335 continue 6336 raise plumbing.convert_error_to_porcelain(e) from e 6337 break 6338 6339 resp = models.ResourceUpdateResponse() 6340 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6341 plumbing_response.meta) 6342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6343 plumbing_response.rate_limit) 6344 resp.resource = plumbing.convert_resource_to_porcelain( 6345 plumbing_response.resource) 6346 return resp 6347 6348 def delete(self, id, timeout=None): 6349 ''' 6350 Delete removes a Resource by ID. 6351 ''' 6352 deadline = None if timeout is None else time.time() + timeout 6353 req = ResourceDeleteRequest() 6354 6355 req.id = (id) 6356 tries = 0 6357 plumbing_response = None 6358 while True: 6359 t = None if deadline is None else deadline - time.time() 6360 try: 6361 plumbing_response = self.stub.Delete( 6362 req, 6363 metadata=self.parent.get_metadata('Resources.Delete', req), 6364 timeout=t) 6365 except Exception as e: 6366 if self.parent.shouldRetry(tries, e, deadline): 6367 tries += 1 6368 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6369 continue 6370 raise plumbing.convert_error_to_porcelain(e) from e 6371 break 6372 6373 resp = models.ResourceDeleteResponse() 6374 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6375 plumbing_response.meta) 6376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6377 plumbing_response.rate_limit) 6378 return resp 6379 6380 def list(self, filter, *args, timeout=None): 6381 ''' 6382 List gets a list of Resources matching a given set of criteria. 6383 ''' 6384 deadline = None if timeout is None else time.time() + timeout 6385 req = ResourceListRequest() 6386 req.meta.CopyFrom(ListRequestMetadata()) 6387 if self.parent.page_limit > 0: 6388 req.meta.limit = self.parent.page_limit 6389 if self.parent.snapshot_datetime is not None: 6390 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6391 6392 req.filter = plumbing.quote_filter_args(filter, *args) 6393 6394 def generator(svc, req): 6395 tries = 0 6396 while True: 6397 t = None if deadline is None else deadline - time.time() 6398 try: 6399 plumbing_response = svc.stub.List( 6400 req, 6401 metadata=svc.parent.get_metadata( 6402 'Resources.List', req), 6403 timeout=t) 6404 except Exception as e: 6405 if self.parent.shouldRetry(tries, e, deadline): 6406 tries += 1 6407 time.sleep( 6408 self.parent.exponentialBackoff(tries, deadline)) 6409 continue 6410 raise plumbing.convert_error_to_porcelain(e) from e 6411 tries = 0 6412 for plumbing_item in plumbing_response.resources: 6413 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6414 if plumbing_response.meta.next_cursor == '': 6415 break 6416 req.meta.cursor = plumbing_response.meta.next_cursor 6417 6418 return generator(self, req) 6419 6420 def healthcheck(self, id, timeout=None): 6421 ''' 6422 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6423 large network of Nodes. The call will return immediately, and the updated health of the 6424 Resource can be retrieved via Get or List. 6425 ''' 6426 deadline = None if timeout is None else time.time() + timeout 6427 req = ResourceHealthcheckRequest() 6428 6429 req.id = (id) 6430 tries = 0 6431 plumbing_response = None 6432 while True: 6433 t = None if deadline is None else deadline - time.time() 6434 try: 6435 plumbing_response = self.stub.Healthcheck( 6436 req, 6437 metadata=self.parent.get_metadata('Resources.Healthcheck', 6438 req), 6439 timeout=t) 6440 except Exception as e: 6441 if self.parent.shouldRetry(tries, e, deadline): 6442 tries += 1 6443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6444 continue 6445 raise plumbing.convert_error_to_porcelain(e) from e 6446 break 6447 6448 resp = models.ResourceHealthcheckResponse() 6449 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6450 plumbing_response.meta) 6451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6452 plumbing_response.rate_limit) 6453 return resp
Resources are databases, servers, clusters, websites, or clouds that strongDM
delegates access to.
See:
strongdm.models.Aerospike
strongdm.models.AKS
strongdm.models.AKSBasicAuth
strongdm.models.AKSServiceAccount
strongdm.models.AKSServiceAccountUserImpersonation
strongdm.models.AKSUserImpersonation
strongdm.models.AmazonEKS
strongdm.models.AmazonEKSInstanceProfile
strongdm.models.AmazonEKSInstanceProfileUserImpersonation
strongdm.models.AmazonEKSUserImpersonation
strongdm.models.AmazonES
strongdm.models.AmazonESIAM
strongdm.models.AmazonMQAMQP091
strongdm.models.AMQP
strongdm.models.Athena
strongdm.models.AthenaIAM
strongdm.models.AuroraMysql
strongdm.models.AuroraMysqlIAM
strongdm.models.AuroraPostgres
strongdm.models.AuroraPostgresIAM
strongdm.models.AWS
strongdm.models.AWSConsole
strongdm.models.AWSConsoleStaticKeyPair
strongdm.models.AWSInstanceProfile
strongdm.models.Azure
strongdm.models.AzureCertificate
strongdm.models.AzureMysql
strongdm.models.AzureMysqlManagedIdentity
strongdm.models.AzurePostgres
strongdm.models.AzurePostgresManagedIdentity
strongdm.models.BigQuery
strongdm.models.Cassandra
strongdm.models.Citus
strongdm.models.ClickHouseHTTP
strongdm.models.ClickHouseMySQL
strongdm.models.ClickHouseTCP
strongdm.models.Clustrix
strongdm.models.Cockroach
strongdm.models.CouchbaseDatabase
strongdm.models.CouchbaseWebUI
strongdm.models.DB2I
strongdm.models.DB2LUW
strongdm.models.DocumentDBHost
strongdm.models.DocumentDBHostIAM
strongdm.models.DocumentDBReplicaSet
strongdm.models.DocumentDBReplicaSetIAM
strongdm.models.Druid
strongdm.models.DynamoDB
strongdm.models.DynamoDBIAM
strongdm.models.Elastic
strongdm.models.ElasticacheRedis
strongdm.models.EntraID
strongdm.models.GCP
strongdm.models.GCPConsole
strongdm.models.GCPWIF
strongdm.models.GoogleGKE
strongdm.models.GoogleGKEUserImpersonation
strongdm.models.Greenplum
strongdm.models.HTTPAuth
strongdm.models.HTTPBasicAuth
strongdm.models.HTTPNoAuth
strongdm.models.Kubernetes
strongdm.models.KubernetesBasicAuth
strongdm.models.KubernetesPodIdentity
strongdm.models.KubernetesServiceAccount
strongdm.models.KubernetesServiceAccountUserImpersonation
strongdm.models.KubernetesUserImpersonation
strongdm.models.Maria
strongdm.models.MCP
strongdm.models.Memcached
strongdm.models.Memsql
strongdm.models.MongoHost
strongdm.models.MongoLegacyHost
strongdm.models.MongoLegacyReplicaset
strongdm.models.MongoReplicaSet
strongdm.models.MongoShardedCluster
strongdm.models.MTLSMysql
strongdm.models.MTLSPostgres
strongdm.models.Mysql
strongdm.models.Neptune
strongdm.models.NeptuneIAM
strongdm.models.Oracle
strongdm.models.OracleNNE
strongdm.models.Postgres
strongdm.models.Presto
strongdm.models.RabbitMQAMQP091
strongdm.models.RawTCP
strongdm.models.RDP
strongdm.models.RDPCert
strongdm.models.RDSPostgresIAM
strongdm.models.Redis
strongdm.models.RedisCluster
strongdm.models.Redshift
strongdm.models.RedshiftIAM
strongdm.models.RedshiftServerlessIAM
strongdm.models.SingleStore
strongdm.models.Snowflake
strongdm.models.Snowsight
strongdm.models.SQLServer
strongdm.models.SQLServerAzureAD
strongdm.models.SQLServerKerberosAD
strongdm.models.SSH
strongdm.models.SSHCert
strongdm.models.SSHCustomerKey
strongdm.models.SSHPassword
strongdm.models.Sybase
strongdm.models.SybaseIQ
strongdm.models.Teradata
strongdm.models.Trino
strongdm.models.Vertica
def
create(self, resource, timeout=None)
6239 def create(self, resource, timeout=None): 6240 ''' 6241 Create registers a new Resource. 6242 ''' 6243 deadline = None if timeout is None else time.time() + timeout 6244 req = ResourceCreateRequest() 6245 6246 if resource is not None: 6247 req.resource.CopyFrom( 6248 plumbing.convert_resource_to_plumbing(resource)) 6249 tries = 0 6250 plumbing_response = None 6251 while True: 6252 t = None if deadline is None else deadline - time.time() 6253 try: 6254 plumbing_response = self.stub.Create( 6255 req, 6256 metadata=self.parent.get_metadata('Resources.Create', req), 6257 timeout=t) 6258 except Exception as e: 6259 if self.parent.shouldRetry(tries, e, deadline): 6260 tries += 1 6261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6262 continue 6263 raise plumbing.convert_error_to_porcelain(e) from e 6264 break 6265 6266 resp = models.ResourceCreateResponse() 6267 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6268 plumbing_response.meta) 6269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6270 plumbing_response.rate_limit) 6271 resp.resource = plumbing.convert_resource_to_porcelain( 6272 plumbing_response.resource) 6273 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
6275 def get(self, id, timeout=None): 6276 ''' 6277 Get reads one Resource by ID. 6278 ''' 6279 deadline = None if timeout is None else time.time() + timeout 6280 req = ResourceGetRequest() 6281 if self.parent.snapshot_datetime is not None: 6282 req.meta.CopyFrom(GetRequestMetadata()) 6283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6284 6285 req.id = (id) 6286 tries = 0 6287 plumbing_response = None 6288 while True: 6289 t = None if deadline is None else deadline - time.time() 6290 try: 6291 plumbing_response = self.stub.Get( 6292 req, 6293 metadata=self.parent.get_metadata('Resources.Get', req), 6294 timeout=t) 6295 except Exception as e: 6296 if self.parent.shouldRetry(tries, e, deadline): 6297 tries += 1 6298 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6299 continue 6300 raise plumbing.convert_error_to_porcelain(e) from e 6301 break 6302 6303 resp = models.ResourceGetResponse() 6304 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6305 plumbing_response.meta) 6306 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6307 plumbing_response.rate_limit) 6308 resp.resource = plumbing.convert_resource_to_porcelain( 6309 plumbing_response.resource) 6310 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
6312 def update(self, resource, timeout=None): 6313 ''' 6314 Update replaces all the fields of a Resource by ID. 6315 ''' 6316 deadline = None if timeout is None else time.time() + timeout 6317 req = ResourceUpdateRequest() 6318 6319 if resource is not None: 6320 req.resource.CopyFrom( 6321 plumbing.convert_resource_to_plumbing(resource)) 6322 tries = 0 6323 plumbing_response = None 6324 while True: 6325 t = None if deadline is None else deadline - time.time() 6326 try: 6327 plumbing_response = self.stub.Update( 6328 req, 6329 metadata=self.parent.get_metadata('Resources.Update', req), 6330 timeout=t) 6331 except Exception as e: 6332 if self.parent.shouldRetry(tries, e, deadline): 6333 tries += 1 6334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6335 continue 6336 raise plumbing.convert_error_to_porcelain(e) from e 6337 break 6338 6339 resp = models.ResourceUpdateResponse() 6340 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6341 plumbing_response.meta) 6342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6343 plumbing_response.rate_limit) 6344 resp.resource = plumbing.convert_resource_to_porcelain( 6345 plumbing_response.resource) 6346 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
6348 def delete(self, id, timeout=None): 6349 ''' 6350 Delete removes a Resource by ID. 6351 ''' 6352 deadline = None if timeout is None else time.time() + timeout 6353 req = ResourceDeleteRequest() 6354 6355 req.id = (id) 6356 tries = 0 6357 plumbing_response = None 6358 while True: 6359 t = None if deadline is None else deadline - time.time() 6360 try: 6361 plumbing_response = self.stub.Delete( 6362 req, 6363 metadata=self.parent.get_metadata('Resources.Delete', req), 6364 timeout=t) 6365 except Exception as e: 6366 if self.parent.shouldRetry(tries, e, deadline): 6367 tries += 1 6368 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6369 continue 6370 raise plumbing.convert_error_to_porcelain(e) from e 6371 break 6372 6373 resp = models.ResourceDeleteResponse() 6374 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6375 plumbing_response.meta) 6376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6377 plumbing_response.rate_limit) 6378 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
6380 def list(self, filter, *args, timeout=None): 6381 ''' 6382 List gets a list of Resources matching a given set of criteria. 6383 ''' 6384 deadline = None if timeout is None else time.time() + timeout 6385 req = ResourceListRequest() 6386 req.meta.CopyFrom(ListRequestMetadata()) 6387 if self.parent.page_limit > 0: 6388 req.meta.limit = self.parent.page_limit 6389 if self.parent.snapshot_datetime is not None: 6390 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6391 6392 req.filter = plumbing.quote_filter_args(filter, *args) 6393 6394 def generator(svc, req): 6395 tries = 0 6396 while True: 6397 t = None if deadline is None else deadline - time.time() 6398 try: 6399 plumbing_response = svc.stub.List( 6400 req, 6401 metadata=svc.parent.get_metadata( 6402 'Resources.List', req), 6403 timeout=t) 6404 except Exception as e: 6405 if self.parent.shouldRetry(tries, e, deadline): 6406 tries += 1 6407 time.sleep( 6408 self.parent.exponentialBackoff(tries, deadline)) 6409 continue 6410 raise plumbing.convert_error_to_porcelain(e) from e 6411 tries = 0 6412 for plumbing_item in plumbing_response.resources: 6413 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6414 if plumbing_response.meta.next_cursor == '': 6415 break 6416 req.meta.cursor = plumbing_response.meta.next_cursor 6417 6418 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
6420 def healthcheck(self, id, timeout=None): 6421 ''' 6422 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6423 large network of Nodes. The call will return immediately, and the updated health of the 6424 Resource can be retrieved via Get or List. 6425 ''' 6426 deadline = None if timeout is None else time.time() + timeout 6427 req = ResourceHealthcheckRequest() 6428 6429 req.id = (id) 6430 tries = 0 6431 plumbing_response = None 6432 while True: 6433 t = None if deadline is None else deadline - time.time() 6434 try: 6435 plumbing_response = self.stub.Healthcheck( 6436 req, 6437 metadata=self.parent.get_metadata('Resources.Healthcheck', 6438 req), 6439 timeout=t) 6440 except Exception as e: 6441 if self.parent.shouldRetry(tries, e, deadline): 6442 tries += 1 6443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6444 continue 6445 raise plumbing.convert_error_to_porcelain(e) from e 6446 break 6447 6448 resp = models.ResourceHealthcheckResponse() 6449 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6450 plumbing_response.meta) 6451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6452 plumbing_response.rate_limit) 6453 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:
6456class SnapshotResources: 6457 ''' 6458 SnapshotResources exposes the read only methods of the Resources 6459 service for historical queries. 6460 ''' 6461 def __init__(self, resources): 6462 self.resources = resources 6463 6464 def get(self, id, timeout=None): 6465 ''' 6466 Get reads one Resource by ID. 6467 ''' 6468 return self.resources.get(id, timeout=timeout) 6469 6470 def list(self, filter, *args, timeout=None): 6471 ''' 6472 List gets a list of Resources matching a given set of criteria. 6473 ''' 6474 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)
6464 def get(self, id, timeout=None): 6465 ''' 6466 Get reads one Resource by ID. 6467 ''' 6468 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
6470 def list(self, filter, *args, timeout=None): 6471 ''' 6472 List gets a list of Resources matching a given set of criteria. 6473 ''' 6474 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
6477class ResourcesHistory: 6478 ''' 6479 ResourcesHistory records all changes to the state of a Resource. 6480 See `strongdm.models.ResourceHistory`. 6481 ''' 6482 def __init__(self, channel, client): 6483 self.parent = client 6484 self.stub = ResourcesHistoryStub(channel) 6485 6486 def list(self, filter, *args, timeout=None): 6487 ''' 6488 List gets a list of ResourceHistory records matching a given set of criteria. 6489 ''' 6490 deadline = None if timeout is None else time.time() + timeout 6491 req = ResourceHistoryListRequest() 6492 req.meta.CopyFrom(ListRequestMetadata()) 6493 if self.parent.page_limit > 0: 6494 req.meta.limit = self.parent.page_limit 6495 if self.parent.snapshot_datetime is not None: 6496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6497 6498 req.filter = plumbing.quote_filter_args(filter, *args) 6499 6500 def generator(svc, req): 6501 tries = 0 6502 while True: 6503 t = None if deadline is None else deadline - time.time() 6504 try: 6505 plumbing_response = svc.stub.List( 6506 req, 6507 metadata=svc.parent.get_metadata( 6508 'ResourcesHistory.List', req), 6509 timeout=t) 6510 except Exception as e: 6511 if self.parent.shouldRetry(tries, e, deadline): 6512 tries += 1 6513 time.sleep( 6514 self.parent.exponentialBackoff(tries, deadline)) 6515 continue 6516 raise plumbing.convert_error_to_porcelain(e) from e 6517 tries = 0 6518 for plumbing_item in plumbing_response.history: 6519 yield plumbing.convert_resource_history_to_porcelain( 6520 plumbing_item) 6521 if plumbing_response.meta.next_cursor == '': 6522 break 6523 req.meta.cursor = plumbing_response.meta.next_cursor 6524 6525 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)
6486 def list(self, filter, *args, timeout=None): 6487 ''' 6488 List gets a list of ResourceHistory records matching a given set of criteria. 6489 ''' 6490 deadline = None if timeout is None else time.time() + timeout 6491 req = ResourceHistoryListRequest() 6492 req.meta.CopyFrom(ListRequestMetadata()) 6493 if self.parent.page_limit > 0: 6494 req.meta.limit = self.parent.page_limit 6495 if self.parent.snapshot_datetime is not None: 6496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6497 6498 req.filter = plumbing.quote_filter_args(filter, *args) 6499 6500 def generator(svc, req): 6501 tries = 0 6502 while True: 6503 t = None if deadline is None else deadline - time.time() 6504 try: 6505 plumbing_response = svc.stub.List( 6506 req, 6507 metadata=svc.parent.get_metadata( 6508 'ResourcesHistory.List', req), 6509 timeout=t) 6510 except Exception as e: 6511 if self.parent.shouldRetry(tries, e, deadline): 6512 tries += 1 6513 time.sleep( 6514 self.parent.exponentialBackoff(tries, deadline)) 6515 continue 6516 raise plumbing.convert_error_to_porcelain(e) from e 6517 tries = 0 6518 for plumbing_item in plumbing_response.history: 6519 yield plumbing.convert_resource_history_to_porcelain( 6520 plumbing_item) 6521 if plumbing_response.meta.next_cursor == '': 6522 break 6523 req.meta.cursor = plumbing_response.meta.next_cursor 6524 6525 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
6528class RoleResources: 6529 ''' 6530 RoleResources enumerates the resources to which roles have access. 6531 The RoleResources service is read-only. 6532 See `strongdm.models.RoleResource`. 6533 ''' 6534 def __init__(self, channel, client): 6535 self.parent = client 6536 self.stub = RoleResourcesStub(channel) 6537 6538 def list(self, filter, *args, timeout=None): 6539 ''' 6540 List gets a list of RoleResource records matching a given set of criteria. 6541 ''' 6542 deadline = None if timeout is None else time.time() + timeout 6543 req = RoleResourceListRequest() 6544 req.meta.CopyFrom(ListRequestMetadata()) 6545 if self.parent.page_limit > 0: 6546 req.meta.limit = self.parent.page_limit 6547 if self.parent.snapshot_datetime is not None: 6548 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6549 6550 req.filter = plumbing.quote_filter_args(filter, *args) 6551 6552 def generator(svc, req): 6553 tries = 0 6554 while True: 6555 t = None if deadline is None else deadline - time.time() 6556 try: 6557 plumbing_response = svc.stub.List( 6558 req, 6559 metadata=svc.parent.get_metadata( 6560 'RoleResources.List', req), 6561 timeout=t) 6562 except Exception as e: 6563 if self.parent.shouldRetry(tries, e, deadline): 6564 tries += 1 6565 time.sleep( 6566 self.parent.exponentialBackoff(tries, deadline)) 6567 continue 6568 raise plumbing.convert_error_to_porcelain(e) from e 6569 tries = 0 6570 for plumbing_item in plumbing_response.role_resources: 6571 yield plumbing.convert_role_resource_to_porcelain( 6572 plumbing_item) 6573 if plumbing_response.meta.next_cursor == '': 6574 break 6575 req.meta.cursor = plumbing_response.meta.next_cursor 6576 6577 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)
6538 def list(self, filter, *args, timeout=None): 6539 ''' 6540 List gets a list of RoleResource records matching a given set of criteria. 6541 ''' 6542 deadline = None if timeout is None else time.time() + timeout 6543 req = RoleResourceListRequest() 6544 req.meta.CopyFrom(ListRequestMetadata()) 6545 if self.parent.page_limit > 0: 6546 req.meta.limit = self.parent.page_limit 6547 if self.parent.snapshot_datetime is not None: 6548 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6549 6550 req.filter = plumbing.quote_filter_args(filter, *args) 6551 6552 def generator(svc, req): 6553 tries = 0 6554 while True: 6555 t = None if deadline is None else deadline - time.time() 6556 try: 6557 plumbing_response = svc.stub.List( 6558 req, 6559 metadata=svc.parent.get_metadata( 6560 'RoleResources.List', req), 6561 timeout=t) 6562 except Exception as e: 6563 if self.parent.shouldRetry(tries, e, deadline): 6564 tries += 1 6565 time.sleep( 6566 self.parent.exponentialBackoff(tries, deadline)) 6567 continue 6568 raise plumbing.convert_error_to_porcelain(e) from e 6569 tries = 0 6570 for plumbing_item in plumbing_response.role_resources: 6571 yield plumbing.convert_role_resource_to_porcelain( 6572 plumbing_item) 6573 if plumbing_response.meta.next_cursor == '': 6574 break 6575 req.meta.cursor = plumbing_response.meta.next_cursor 6576 6577 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
6580class SnapshotRoleResources: 6581 ''' 6582 SnapshotRoleResources exposes the read only methods of the RoleResources 6583 service for historical queries. 6584 ''' 6585 def __init__(self, role_resources): 6586 self.role_resources = role_resources 6587 6588 def list(self, filter, *args, timeout=None): 6589 ''' 6590 List gets a list of RoleResource records matching a given set of criteria. 6591 ''' 6592 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)
6588 def list(self, filter, *args, timeout=None): 6589 ''' 6590 List gets a list of RoleResource records matching a given set of criteria. 6591 ''' 6592 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
6595class RoleResourcesHistory: 6596 ''' 6597 RoleResourcesHistory records all changes to the state of a RoleResource. 6598 See `strongdm.models.RoleResourceHistory`. 6599 ''' 6600 def __init__(self, channel, client): 6601 self.parent = client 6602 self.stub = RoleResourcesHistoryStub(channel) 6603 6604 def list(self, filter, *args, timeout=None): 6605 ''' 6606 List gets a list of RoleResourceHistory records matching a given set of criteria. 6607 ''' 6608 deadline = None if timeout is None else time.time() + timeout 6609 req = RoleResourceHistoryListRequest() 6610 req.meta.CopyFrom(ListRequestMetadata()) 6611 if self.parent.page_limit > 0: 6612 req.meta.limit = self.parent.page_limit 6613 if self.parent.snapshot_datetime is not None: 6614 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6615 6616 req.filter = plumbing.quote_filter_args(filter, *args) 6617 6618 def generator(svc, req): 6619 tries = 0 6620 while True: 6621 t = None if deadline is None else deadline - time.time() 6622 try: 6623 plumbing_response = svc.stub.List( 6624 req, 6625 metadata=svc.parent.get_metadata( 6626 'RoleResourcesHistory.List', req), 6627 timeout=t) 6628 except Exception as e: 6629 if self.parent.shouldRetry(tries, e, deadline): 6630 tries += 1 6631 time.sleep( 6632 self.parent.exponentialBackoff(tries, deadline)) 6633 continue 6634 raise plumbing.convert_error_to_porcelain(e) from e 6635 tries = 0 6636 for plumbing_item in plumbing_response.history: 6637 yield plumbing.convert_role_resource_history_to_porcelain( 6638 plumbing_item) 6639 if plumbing_response.meta.next_cursor == '': 6640 break 6641 req.meta.cursor = plumbing_response.meta.next_cursor 6642 6643 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)
6604 def list(self, filter, *args, timeout=None): 6605 ''' 6606 List gets a list of RoleResourceHistory records matching a given set of criteria. 6607 ''' 6608 deadline = None if timeout is None else time.time() + timeout 6609 req = RoleResourceHistoryListRequest() 6610 req.meta.CopyFrom(ListRequestMetadata()) 6611 if self.parent.page_limit > 0: 6612 req.meta.limit = self.parent.page_limit 6613 if self.parent.snapshot_datetime is not None: 6614 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6615 6616 req.filter = plumbing.quote_filter_args(filter, *args) 6617 6618 def generator(svc, req): 6619 tries = 0 6620 while True: 6621 t = None if deadline is None else deadline - time.time() 6622 try: 6623 plumbing_response = svc.stub.List( 6624 req, 6625 metadata=svc.parent.get_metadata( 6626 'RoleResourcesHistory.List', req), 6627 timeout=t) 6628 except Exception as e: 6629 if self.parent.shouldRetry(tries, e, deadline): 6630 tries += 1 6631 time.sleep( 6632 self.parent.exponentialBackoff(tries, deadline)) 6633 continue 6634 raise plumbing.convert_error_to_porcelain(e) from e 6635 tries = 0 6636 for plumbing_item in plumbing_response.history: 6637 yield plumbing.convert_role_resource_history_to_porcelain( 6638 plumbing_item) 6639 if plumbing_response.meta.next_cursor == '': 6640 break 6641 req.meta.cursor = plumbing_response.meta.next_cursor 6642 6643 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
6646class RolesHistory: 6647 ''' 6648 RolesHistory records all changes to the state of a Role. 6649 See `strongdm.models.RoleHistory`. 6650 ''' 6651 def __init__(self, channel, client): 6652 self.parent = client 6653 self.stub = RolesHistoryStub(channel) 6654 6655 def list(self, filter, *args, timeout=None): 6656 ''' 6657 List gets a list of RoleHistory records matching a given set of criteria. 6658 ''' 6659 deadline = None if timeout is None else time.time() + timeout 6660 req = RoleHistoryListRequest() 6661 req.meta.CopyFrom(ListRequestMetadata()) 6662 if self.parent.page_limit > 0: 6663 req.meta.limit = self.parent.page_limit 6664 if self.parent.snapshot_datetime is not None: 6665 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6666 6667 req.filter = plumbing.quote_filter_args(filter, *args) 6668 6669 def generator(svc, req): 6670 tries = 0 6671 while True: 6672 t = None if deadline is None else deadline - time.time() 6673 try: 6674 plumbing_response = svc.stub.List( 6675 req, 6676 metadata=svc.parent.get_metadata( 6677 'RolesHistory.List', req), 6678 timeout=t) 6679 except Exception as e: 6680 if self.parent.shouldRetry(tries, e, deadline): 6681 tries += 1 6682 time.sleep( 6683 self.parent.exponentialBackoff(tries, deadline)) 6684 continue 6685 raise plumbing.convert_error_to_porcelain(e) from e 6686 tries = 0 6687 for plumbing_item in plumbing_response.history: 6688 yield plumbing.convert_role_history_to_porcelain( 6689 plumbing_item) 6690 if plumbing_response.meta.next_cursor == '': 6691 break 6692 req.meta.cursor = plumbing_response.meta.next_cursor 6693 6694 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)
6655 def list(self, filter, *args, timeout=None): 6656 ''' 6657 List gets a list of RoleHistory records matching a given set of criteria. 6658 ''' 6659 deadline = None if timeout is None else time.time() + timeout 6660 req = RoleHistoryListRequest() 6661 req.meta.CopyFrom(ListRequestMetadata()) 6662 if self.parent.page_limit > 0: 6663 req.meta.limit = self.parent.page_limit 6664 if self.parent.snapshot_datetime is not None: 6665 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6666 6667 req.filter = plumbing.quote_filter_args(filter, *args) 6668 6669 def generator(svc, req): 6670 tries = 0 6671 while True: 6672 t = None if deadline is None else deadline - time.time() 6673 try: 6674 plumbing_response = svc.stub.List( 6675 req, 6676 metadata=svc.parent.get_metadata( 6677 'RolesHistory.List', req), 6678 timeout=t) 6679 except Exception as e: 6680 if self.parent.shouldRetry(tries, e, deadline): 6681 tries += 1 6682 time.sleep( 6683 self.parent.exponentialBackoff(tries, deadline)) 6684 continue 6685 raise plumbing.convert_error_to_porcelain(e) from e 6686 tries = 0 6687 for plumbing_item in plumbing_response.history: 6688 yield plumbing.convert_role_history_to_porcelain( 6689 plumbing_item) 6690 if plumbing_response.meta.next_cursor == '': 6691 break 6692 req.meta.cursor = plumbing_response.meta.next_cursor 6693 6694 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
6697class SecretStores: 6698 ''' 6699 SecretStores are servers where resource secrets (passwords, keys) are stored. 6700 See: 6701 `strongdm.models.ActiveDirectoryStore` 6702 `strongdm.models.AWSStore` 6703 `strongdm.models.AWSCertX509Store` 6704 `strongdm.models.AzureStore` 6705 `strongdm.models.CyberarkConjurStore` 6706 `strongdm.models.CyberarkPAMStore` 6707 `strongdm.models.CyberarkPAMExperimentalStore` 6708 `strongdm.models.DelineaStore` 6709 `strongdm.models.GCPStore` 6710 `strongdm.models.GCPCertX509Store` 6711 `strongdm.models.KeyfactorSSHStore` 6712 `strongdm.models.KeyfactorX509Store` 6713 `strongdm.models.VaultAppRoleStore` 6714 `strongdm.models.VaultAppRoleCertSSHStore` 6715 `strongdm.models.VaultAppRoleCertX509Store` 6716 `strongdm.models.VaultAWSEC2Store` 6717 `strongdm.models.VaultAWSEC2CertSSHStore` 6718 `strongdm.models.VaultAWSEC2CertX509Store` 6719 `strongdm.models.VaultAWSIAMStore` 6720 `strongdm.models.VaultAWSIAMCertSSHStore` 6721 `strongdm.models.VaultAWSIAMCertX509Store` 6722 `strongdm.models.VaultTLSStore` 6723 `strongdm.models.VaultTLSCertSSHStore` 6724 `strongdm.models.VaultTLSCertX509Store` 6725 `strongdm.models.VaultTokenStore` 6726 `strongdm.models.VaultTokenCertSSHStore` 6727 `strongdm.models.VaultTokenCertX509Store` 6728 ''' 6729 def __init__(self, channel, client): 6730 self.parent = client 6731 self.stub = SecretStoresStub(channel) 6732 6733 def create(self, secret_store, timeout=None): 6734 deadline = None if timeout is None else time.time() + timeout 6735 req = SecretStoreCreateRequest() 6736 6737 if secret_store is not None: 6738 req.secret_store.CopyFrom( 6739 plumbing.convert_secret_store_to_plumbing(secret_store)) 6740 tries = 0 6741 plumbing_response = None 6742 while True: 6743 t = None if deadline is None else deadline - time.time() 6744 try: 6745 plumbing_response = self.stub.Create( 6746 req, 6747 metadata=self.parent.get_metadata('SecretStores.Create', 6748 req), 6749 timeout=t) 6750 except Exception as e: 6751 if self.parent.shouldRetry(tries, e, deadline): 6752 tries += 1 6753 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6754 continue 6755 raise plumbing.convert_error_to_porcelain(e) from e 6756 break 6757 6758 resp = models.SecretStoreCreateResponse() 6759 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6760 plumbing_response.meta) 6761 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6762 plumbing_response.rate_limit) 6763 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6764 plumbing_response.secret_store) 6765 return resp 6766 6767 def get(self, id, timeout=None): 6768 ''' 6769 Get reads one SecretStore by ID. 6770 ''' 6771 deadline = None if timeout is None else time.time() + timeout 6772 req = SecretStoreGetRequest() 6773 if self.parent.snapshot_datetime is not None: 6774 req.meta.CopyFrom(GetRequestMetadata()) 6775 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6776 6777 req.id = (id) 6778 tries = 0 6779 plumbing_response = None 6780 while True: 6781 t = None if deadline is None else deadline - time.time() 6782 try: 6783 plumbing_response = self.stub.Get( 6784 req, 6785 metadata=self.parent.get_metadata('SecretStores.Get', req), 6786 timeout=t) 6787 except Exception as e: 6788 if self.parent.shouldRetry(tries, e, deadline): 6789 tries += 1 6790 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6791 continue 6792 raise plumbing.convert_error_to_porcelain(e) from e 6793 break 6794 6795 resp = models.SecretStoreGetResponse() 6796 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6797 plumbing_response.meta) 6798 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6799 plumbing_response.rate_limit) 6800 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6801 plumbing_response.secret_store) 6802 return resp 6803 6804 def update(self, secret_store, timeout=None): 6805 ''' 6806 Update replaces all the fields of a SecretStore by ID. 6807 ''' 6808 deadline = None if timeout is None else time.time() + timeout 6809 req = SecretStoreUpdateRequest() 6810 6811 if secret_store is not None: 6812 req.secret_store.CopyFrom( 6813 plumbing.convert_secret_store_to_plumbing(secret_store)) 6814 tries = 0 6815 plumbing_response = None 6816 while True: 6817 t = None if deadline is None else deadline - time.time() 6818 try: 6819 plumbing_response = self.stub.Update( 6820 req, 6821 metadata=self.parent.get_metadata('SecretStores.Update', 6822 req), 6823 timeout=t) 6824 except Exception as e: 6825 if self.parent.shouldRetry(tries, e, deadline): 6826 tries += 1 6827 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6828 continue 6829 raise plumbing.convert_error_to_porcelain(e) from e 6830 break 6831 6832 resp = models.SecretStoreUpdateResponse() 6833 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6834 plumbing_response.meta) 6835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6836 plumbing_response.rate_limit) 6837 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6838 plumbing_response.secret_store) 6839 return resp 6840 6841 def delete(self, id, timeout=None): 6842 ''' 6843 Delete removes a SecretStore by ID. 6844 ''' 6845 deadline = None if timeout is None else time.time() + timeout 6846 req = SecretStoreDeleteRequest() 6847 6848 req.id = (id) 6849 tries = 0 6850 plumbing_response = None 6851 while True: 6852 t = None if deadline is None else deadline - time.time() 6853 try: 6854 plumbing_response = self.stub.Delete( 6855 req, 6856 metadata=self.parent.get_metadata('SecretStores.Delete', 6857 req), 6858 timeout=t) 6859 except Exception as e: 6860 if self.parent.shouldRetry(tries, e, deadline): 6861 tries += 1 6862 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6863 continue 6864 raise plumbing.convert_error_to_porcelain(e) from e 6865 break 6866 6867 resp = models.SecretStoreDeleteResponse() 6868 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6869 plumbing_response.meta) 6870 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6871 plumbing_response.rate_limit) 6872 return resp 6873 6874 def list(self, filter, *args, timeout=None): 6875 ''' 6876 List gets a list of SecretStores matching a given set of criteria. 6877 ''' 6878 deadline = None if timeout is None else time.time() + timeout 6879 req = SecretStoreListRequest() 6880 req.meta.CopyFrom(ListRequestMetadata()) 6881 if self.parent.page_limit > 0: 6882 req.meta.limit = self.parent.page_limit 6883 if self.parent.snapshot_datetime is not None: 6884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6885 6886 req.filter = plumbing.quote_filter_args(filter, *args) 6887 6888 def generator(svc, req): 6889 tries = 0 6890 while True: 6891 t = None if deadline is None else deadline - time.time() 6892 try: 6893 plumbing_response = svc.stub.List( 6894 req, 6895 metadata=svc.parent.get_metadata( 6896 'SecretStores.List', req), 6897 timeout=t) 6898 except Exception as e: 6899 if self.parent.shouldRetry(tries, e, deadline): 6900 tries += 1 6901 time.sleep( 6902 self.parent.exponentialBackoff(tries, deadline)) 6903 continue 6904 raise plumbing.convert_error_to_porcelain(e) from e 6905 tries = 0 6906 for plumbing_item in plumbing_response.secret_stores: 6907 yield plumbing.convert_secret_store_to_porcelain( 6908 plumbing_item) 6909 if plumbing_response.meta.next_cursor == '': 6910 break 6911 req.meta.cursor = plumbing_response.meta.next_cursor 6912 6913 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.VaultAWSEC2CertSSHStore
strongdm.models.VaultAWSEC2CertX509Store
strongdm.models.VaultAWSIAMStore
strongdm.models.VaultAWSIAMCertSSHStore
strongdm.models.VaultAWSIAMCertX509Store
strongdm.models.VaultTLSStore
strongdm.models.VaultTLSCertSSHStore
strongdm.models.VaultTLSCertX509Store
strongdm.models.VaultTokenStore
strongdm.models.VaultTokenCertSSHStore
strongdm.models.VaultTokenCertX509Store
def
create(self, secret_store, timeout=None)
6733 def create(self, secret_store, timeout=None): 6734 deadline = None if timeout is None else time.time() + timeout 6735 req = SecretStoreCreateRequest() 6736 6737 if secret_store is not None: 6738 req.secret_store.CopyFrom( 6739 plumbing.convert_secret_store_to_plumbing(secret_store)) 6740 tries = 0 6741 plumbing_response = None 6742 while True: 6743 t = None if deadline is None else deadline - time.time() 6744 try: 6745 plumbing_response = self.stub.Create( 6746 req, 6747 metadata=self.parent.get_metadata('SecretStores.Create', 6748 req), 6749 timeout=t) 6750 except Exception as e: 6751 if self.parent.shouldRetry(tries, e, deadline): 6752 tries += 1 6753 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6754 continue 6755 raise plumbing.convert_error_to_porcelain(e) from e 6756 break 6757 6758 resp = models.SecretStoreCreateResponse() 6759 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6760 plumbing_response.meta) 6761 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6762 plumbing_response.rate_limit) 6763 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6764 plumbing_response.secret_store) 6765 return resp
def
get(self, id, timeout=None)
6767 def get(self, id, timeout=None): 6768 ''' 6769 Get reads one SecretStore by ID. 6770 ''' 6771 deadline = None if timeout is None else time.time() + timeout 6772 req = SecretStoreGetRequest() 6773 if self.parent.snapshot_datetime is not None: 6774 req.meta.CopyFrom(GetRequestMetadata()) 6775 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6776 6777 req.id = (id) 6778 tries = 0 6779 plumbing_response = None 6780 while True: 6781 t = None if deadline is None else deadline - time.time() 6782 try: 6783 plumbing_response = self.stub.Get( 6784 req, 6785 metadata=self.parent.get_metadata('SecretStores.Get', req), 6786 timeout=t) 6787 except Exception as e: 6788 if self.parent.shouldRetry(tries, e, deadline): 6789 tries += 1 6790 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6791 continue 6792 raise plumbing.convert_error_to_porcelain(e) from e 6793 break 6794 6795 resp = models.SecretStoreGetResponse() 6796 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6797 plumbing_response.meta) 6798 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6799 plumbing_response.rate_limit) 6800 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6801 plumbing_response.secret_store) 6802 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
6804 def update(self, secret_store, timeout=None): 6805 ''' 6806 Update replaces all the fields of a SecretStore by ID. 6807 ''' 6808 deadline = None if timeout is None else time.time() + timeout 6809 req = SecretStoreUpdateRequest() 6810 6811 if secret_store is not None: 6812 req.secret_store.CopyFrom( 6813 plumbing.convert_secret_store_to_plumbing(secret_store)) 6814 tries = 0 6815 plumbing_response = None 6816 while True: 6817 t = None if deadline is None else deadline - time.time() 6818 try: 6819 plumbing_response = self.stub.Update( 6820 req, 6821 metadata=self.parent.get_metadata('SecretStores.Update', 6822 req), 6823 timeout=t) 6824 except Exception as e: 6825 if self.parent.shouldRetry(tries, e, deadline): 6826 tries += 1 6827 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6828 continue 6829 raise plumbing.convert_error_to_porcelain(e) from e 6830 break 6831 6832 resp = models.SecretStoreUpdateResponse() 6833 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6834 plumbing_response.meta) 6835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6836 plumbing_response.rate_limit) 6837 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6838 plumbing_response.secret_store) 6839 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
6841 def delete(self, id, timeout=None): 6842 ''' 6843 Delete removes a SecretStore by ID. 6844 ''' 6845 deadline = None if timeout is None else time.time() + timeout 6846 req = SecretStoreDeleteRequest() 6847 6848 req.id = (id) 6849 tries = 0 6850 plumbing_response = None 6851 while True: 6852 t = None if deadline is None else deadline - time.time() 6853 try: 6854 plumbing_response = self.stub.Delete( 6855 req, 6856 metadata=self.parent.get_metadata('SecretStores.Delete', 6857 req), 6858 timeout=t) 6859 except Exception as e: 6860 if self.parent.shouldRetry(tries, e, deadline): 6861 tries += 1 6862 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6863 continue 6864 raise plumbing.convert_error_to_porcelain(e) from e 6865 break 6866 6867 resp = models.SecretStoreDeleteResponse() 6868 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6869 plumbing_response.meta) 6870 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6871 plumbing_response.rate_limit) 6872 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6874 def list(self, filter, *args, timeout=None): 6875 ''' 6876 List gets a list of SecretStores matching a given set of criteria. 6877 ''' 6878 deadline = None if timeout is None else time.time() + timeout 6879 req = SecretStoreListRequest() 6880 req.meta.CopyFrom(ListRequestMetadata()) 6881 if self.parent.page_limit > 0: 6882 req.meta.limit = self.parent.page_limit 6883 if self.parent.snapshot_datetime is not None: 6884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6885 6886 req.filter = plumbing.quote_filter_args(filter, *args) 6887 6888 def generator(svc, req): 6889 tries = 0 6890 while True: 6891 t = None if deadline is None else deadline - time.time() 6892 try: 6893 plumbing_response = svc.stub.List( 6894 req, 6895 metadata=svc.parent.get_metadata( 6896 'SecretStores.List', req), 6897 timeout=t) 6898 except Exception as e: 6899 if self.parent.shouldRetry(tries, e, deadline): 6900 tries += 1 6901 time.sleep( 6902 self.parent.exponentialBackoff(tries, deadline)) 6903 continue 6904 raise plumbing.convert_error_to_porcelain(e) from e 6905 tries = 0 6906 for plumbing_item in plumbing_response.secret_stores: 6907 yield plumbing.convert_secret_store_to_porcelain( 6908 plumbing_item) 6909 if plumbing_response.meta.next_cursor == '': 6910 break 6911 req.meta.cursor = plumbing_response.meta.next_cursor 6912 6913 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
6916class SnapshotSecretStores: 6917 ''' 6918 SnapshotSecretStores exposes the read only methods of the SecretStores 6919 service for historical queries. 6920 ''' 6921 def __init__(self, secret_stores): 6922 self.secret_stores = secret_stores 6923 6924 def get(self, id, timeout=None): 6925 ''' 6926 Get reads one SecretStore by ID. 6927 ''' 6928 return self.secret_stores.get(id, timeout=timeout) 6929 6930 def list(self, filter, *args, timeout=None): 6931 ''' 6932 List gets a list of SecretStores matching a given set of criteria. 6933 ''' 6934 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)
6924 def get(self, id, timeout=None): 6925 ''' 6926 Get reads one SecretStore by ID. 6927 ''' 6928 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6930 def list(self, filter, *args, timeout=None): 6931 ''' 6932 List gets a list of SecretStores matching a given set of criteria. 6933 ''' 6934 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
6937class SecretEngines: 6938 ''' 6939 6940 See: 6941 `strongdm.models.ActiveDirectoryEngine` 6942 `strongdm.models.KeyValueEngine` 6943 `strongdm.models.PostgresEngine` 6944 ''' 6945 def __init__(self, channel, client): 6946 self.parent = client 6947 self.stub = SecretEnginesStub(channel) 6948 6949 def list(self, filter, *args, timeout=None): 6950 ''' 6951 List returns a list of Secret Engines 6952 ''' 6953 deadline = None if timeout is None else time.time() + timeout 6954 req = SecretEngineListRequest() 6955 req.meta.CopyFrom(ListRequestMetadata()) 6956 if self.parent.page_limit > 0: 6957 req.meta.limit = self.parent.page_limit 6958 if self.parent.snapshot_datetime is not None: 6959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6960 6961 req.filter = plumbing.quote_filter_args(filter, *args) 6962 6963 def generator(svc, req): 6964 tries = 0 6965 while True: 6966 t = None if deadline is None else deadline - time.time() 6967 try: 6968 plumbing_response = svc.stub.List( 6969 req, 6970 metadata=svc.parent.get_metadata( 6971 'SecretEngines.List', req), 6972 timeout=t) 6973 except Exception as e: 6974 if self.parent.shouldRetry(tries, e, deadline): 6975 tries += 1 6976 time.sleep( 6977 self.parent.exponentialBackoff(tries, deadline)) 6978 continue 6979 raise plumbing.convert_error_to_porcelain(e) from e 6980 tries = 0 6981 for plumbing_item in plumbing_response.secret_engines: 6982 yield plumbing.convert_secret_engine_to_porcelain( 6983 plumbing_item) 6984 if plumbing_response.meta.next_cursor == '': 6985 break 6986 req.meta.cursor = plumbing_response.meta.next_cursor 6987 6988 return generator(self, req) 6989 6990 def get(self, id, timeout=None): 6991 ''' 6992 Get returns a secret engine details 6993 ''' 6994 deadline = None if timeout is None else time.time() + timeout 6995 req = SecretEngineGetRequest() 6996 if self.parent.snapshot_datetime is not None: 6997 req.meta.CopyFrom(GetRequestMetadata()) 6998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6999 7000 req.id = (id) 7001 tries = 0 7002 plumbing_response = None 7003 while True: 7004 t = None if deadline is None else deadline - time.time() 7005 try: 7006 plumbing_response = self.stub.Get( 7007 req, 7008 metadata=self.parent.get_metadata('SecretEngines.Get', 7009 req), 7010 timeout=t) 7011 except Exception as e: 7012 if self.parent.shouldRetry(tries, e, deadline): 7013 tries += 1 7014 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7015 continue 7016 raise plumbing.convert_error_to_porcelain(e) from e 7017 break 7018 7019 resp = models.SecretEngineGetResponse() 7020 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7021 plumbing_response.meta) 7022 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7023 plumbing_response.rate_limit) 7024 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7025 plumbing_response.secret_engine) 7026 return resp 7027 7028 def create(self, secret_engine, timeout=None): 7029 ''' 7030 Create creates a secret engine 7031 ''' 7032 deadline = None if timeout is None else time.time() + timeout 7033 req = SecretEngineCreateRequest() 7034 7035 if secret_engine is not None: 7036 req.secret_engine.CopyFrom( 7037 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7038 tries = 0 7039 plumbing_response = None 7040 while True: 7041 t = None if deadline is None else deadline - time.time() 7042 try: 7043 plumbing_response = self.stub.Create( 7044 req, 7045 metadata=self.parent.get_metadata('SecretEngines.Create', 7046 req), 7047 timeout=t) 7048 except Exception as e: 7049 if self.parent.shouldRetry(tries, e, deadline): 7050 tries += 1 7051 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7052 continue 7053 raise plumbing.convert_error_to_porcelain(e) from e 7054 break 7055 7056 resp = models.SecretEngineCreateResponse() 7057 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7058 plumbing_response.meta) 7059 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7060 plumbing_response.rate_limit) 7061 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7062 plumbing_response.secret_engine) 7063 return resp 7064 7065 def update(self, secret_engine, timeout=None): 7066 ''' 7067 Update updates a secret engine 7068 ''' 7069 deadline = None if timeout is None else time.time() + timeout 7070 req = SecretEngineUpdateRequest() 7071 7072 if secret_engine is not None: 7073 req.secret_engine.CopyFrom( 7074 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7075 tries = 0 7076 plumbing_response = None 7077 while True: 7078 t = None if deadline is None else deadline - time.time() 7079 try: 7080 plumbing_response = self.stub.Update( 7081 req, 7082 metadata=self.parent.get_metadata('SecretEngines.Update', 7083 req), 7084 timeout=t) 7085 except Exception as e: 7086 if self.parent.shouldRetry(tries, e, deadline): 7087 tries += 1 7088 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7089 continue 7090 raise plumbing.convert_error_to_porcelain(e) from e 7091 break 7092 7093 resp = models.SecretEngineUpdateResponse() 7094 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7095 plumbing_response.meta) 7096 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7097 plumbing_response.rate_limit) 7098 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7099 plumbing_response.secret_engine) 7100 return resp 7101 7102 def delete(self, id, timeout=None): 7103 ''' 7104 Delete deletes a secret engine 7105 ''' 7106 deadline = None if timeout is None else time.time() + timeout 7107 req = SecretEngineDeleteRequest() 7108 7109 req.id = (id) 7110 tries = 0 7111 plumbing_response = None 7112 while True: 7113 t = None if deadline is None else deadline - time.time() 7114 try: 7115 plumbing_response = self.stub.Delete( 7116 req, 7117 metadata=self.parent.get_metadata('SecretEngines.Delete', 7118 req), 7119 timeout=t) 7120 except Exception as e: 7121 if self.parent.shouldRetry(tries, e, deadline): 7122 tries += 1 7123 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7124 continue 7125 raise plumbing.convert_error_to_porcelain(e) from e 7126 break 7127 7128 resp = models.SecretEngineDeleteResponse() 7129 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7130 plumbing_response.rate_limit) 7131 return resp 7132 7133 def list_secret_stores(self, filter, *args, timeout=None): 7134 ''' 7135 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7136 for Secret Engine 7137 ''' 7138 deadline = None if timeout is None else time.time() + timeout 7139 req = SecretStoreListRequest() 7140 req.meta.CopyFrom(ListRequestMetadata()) 7141 if self.parent.page_limit > 0: 7142 req.meta.limit = self.parent.page_limit 7143 if self.parent.snapshot_datetime is not None: 7144 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7145 7146 req.filter = plumbing.quote_filter_args(filter, *args) 7147 7148 def generator(svc, req): 7149 tries = 0 7150 while True: 7151 t = None if deadline is None else deadline - time.time() 7152 try: 7153 plumbing_response = svc.stub.ListSecretStores( 7154 req, 7155 metadata=svc.parent.get_metadata( 7156 'SecretEngines.ListSecretStores', req), 7157 timeout=t) 7158 except Exception as e: 7159 if self.parent.shouldRetry(tries, e, deadline): 7160 tries += 1 7161 time.sleep( 7162 self.parent.exponentialBackoff(tries, deadline)) 7163 continue 7164 raise plumbing.convert_error_to_porcelain(e) from e 7165 tries = 0 7166 for plumbing_item in plumbing_response.secret_stores: 7167 yield plumbing.convert_secret_store_to_porcelain( 7168 plumbing_item) 7169 if plumbing_response.meta.next_cursor == '': 7170 break 7171 req.meta.cursor = plumbing_response.meta.next_cursor 7172 7173 return generator(self, req) 7174 7175 def generate_keys(self, secret_engine_id, timeout=None): 7176 ''' 7177 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7178 ''' 7179 deadline = None if timeout is None else time.time() + timeout 7180 req = GenerateKeysRequest() 7181 7182 req.secret_engine_id = (secret_engine_id) 7183 tries = 0 7184 plumbing_response = None 7185 while True: 7186 t = None if deadline is None else deadline - time.time() 7187 try: 7188 plumbing_response = self.stub.GenerateKeys( 7189 req, 7190 metadata=self.parent.get_metadata( 7191 'SecretEngines.GenerateKeys', req), 7192 timeout=t) 7193 except Exception as e: 7194 if self.parent.shouldRetry(tries, e, deadline): 7195 tries += 1 7196 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7197 continue 7198 raise plumbing.convert_error_to_porcelain(e) from e 7199 break 7200 7201 resp = models.GenerateKeysResponse() 7202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7203 plumbing_response.rate_limit) 7204 return resp 7205 7206 def healthcheck(self, secret_engine_id, timeout=None): 7207 ''' 7208 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7209 ''' 7210 deadline = None if timeout is None else time.time() + timeout 7211 req = HealthcheckRequest() 7212 7213 req.secret_engine_id = (secret_engine_id) 7214 tries = 0 7215 plumbing_response = None 7216 while True: 7217 t = None if deadline is None else deadline - time.time() 7218 try: 7219 plumbing_response = self.stub.Healthcheck( 7220 req, 7221 metadata=self.parent.get_metadata( 7222 'SecretEngines.Healthcheck', req), 7223 timeout=t) 7224 except Exception as e: 7225 if self.parent.shouldRetry(tries, e, deadline): 7226 tries += 1 7227 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7228 continue 7229 raise plumbing.convert_error_to_porcelain(e) from e 7230 break 7231 7232 resp = models.HealthcheckResponse() 7233 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7234 plumbing_response.rate_limit) 7235 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7236 plumbing_response.status) 7237 return resp 7238 7239 def rotate(self, id, password_policy, timeout=None): 7240 ''' 7241 Rotate rotates secret engine's credentials 7242 ''' 7243 deadline = None if timeout is None else time.time() + timeout 7244 req = SecretEngineRotateRequest() 7245 7246 req.id = (id) 7247 if password_policy is not None: 7248 req.password_policy.CopyFrom( 7249 plumbing.convert_secret_engine_password_policy_to_plumbing( 7250 password_policy)) 7251 tries = 0 7252 plumbing_response = None 7253 while True: 7254 t = None if deadline is None else deadline - time.time() 7255 try: 7256 plumbing_response = self.stub.Rotate( 7257 req, 7258 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7259 req), 7260 timeout=t) 7261 except Exception as e: 7262 if self.parent.shouldRetry(tries, e, deadline): 7263 tries += 1 7264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7265 continue 7266 raise plumbing.convert_error_to_porcelain(e) from e 7267 break 7268 7269 resp = models.SecretEngineRotateResponse() 7270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7271 plumbing_response.rate_limit) 7272 return resp
See:
strongdm.models.ActiveDirectoryEngine
strongdm.models.KeyValueEngine
strongdm.models.PostgresEngine
def
list(self, filter, *args, timeout=None)
6949 def list(self, filter, *args, timeout=None): 6950 ''' 6951 List returns a list of Secret Engines 6952 ''' 6953 deadline = None if timeout is None else time.time() + timeout 6954 req = SecretEngineListRequest() 6955 req.meta.CopyFrom(ListRequestMetadata()) 6956 if self.parent.page_limit > 0: 6957 req.meta.limit = self.parent.page_limit 6958 if self.parent.snapshot_datetime is not None: 6959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6960 6961 req.filter = plumbing.quote_filter_args(filter, *args) 6962 6963 def generator(svc, req): 6964 tries = 0 6965 while True: 6966 t = None if deadline is None else deadline - time.time() 6967 try: 6968 plumbing_response = svc.stub.List( 6969 req, 6970 metadata=svc.parent.get_metadata( 6971 'SecretEngines.List', req), 6972 timeout=t) 6973 except Exception as e: 6974 if self.parent.shouldRetry(tries, e, deadline): 6975 tries += 1 6976 time.sleep( 6977 self.parent.exponentialBackoff(tries, deadline)) 6978 continue 6979 raise plumbing.convert_error_to_porcelain(e) from e 6980 tries = 0 6981 for plumbing_item in plumbing_response.secret_engines: 6982 yield plumbing.convert_secret_engine_to_porcelain( 6983 plumbing_item) 6984 if plumbing_response.meta.next_cursor == '': 6985 break 6986 req.meta.cursor = plumbing_response.meta.next_cursor 6987 6988 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
6990 def get(self, id, timeout=None): 6991 ''' 6992 Get returns a secret engine details 6993 ''' 6994 deadline = None if timeout is None else time.time() + timeout 6995 req = SecretEngineGetRequest() 6996 if self.parent.snapshot_datetime is not None: 6997 req.meta.CopyFrom(GetRequestMetadata()) 6998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6999 7000 req.id = (id) 7001 tries = 0 7002 plumbing_response = None 7003 while True: 7004 t = None if deadline is None else deadline - time.time() 7005 try: 7006 plumbing_response = self.stub.Get( 7007 req, 7008 metadata=self.parent.get_metadata('SecretEngines.Get', 7009 req), 7010 timeout=t) 7011 except Exception as e: 7012 if self.parent.shouldRetry(tries, e, deadline): 7013 tries += 1 7014 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7015 continue 7016 raise plumbing.convert_error_to_porcelain(e) from e 7017 break 7018 7019 resp = models.SecretEngineGetResponse() 7020 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7021 plumbing_response.meta) 7022 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7023 plumbing_response.rate_limit) 7024 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7025 plumbing_response.secret_engine) 7026 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7028 def create(self, secret_engine, timeout=None): 7029 ''' 7030 Create creates a secret engine 7031 ''' 7032 deadline = None if timeout is None else time.time() + timeout 7033 req = SecretEngineCreateRequest() 7034 7035 if secret_engine is not None: 7036 req.secret_engine.CopyFrom( 7037 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7038 tries = 0 7039 plumbing_response = None 7040 while True: 7041 t = None if deadline is None else deadline - time.time() 7042 try: 7043 plumbing_response = self.stub.Create( 7044 req, 7045 metadata=self.parent.get_metadata('SecretEngines.Create', 7046 req), 7047 timeout=t) 7048 except Exception as e: 7049 if self.parent.shouldRetry(tries, e, deadline): 7050 tries += 1 7051 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7052 continue 7053 raise plumbing.convert_error_to_porcelain(e) from e 7054 break 7055 7056 resp = models.SecretEngineCreateResponse() 7057 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7058 plumbing_response.meta) 7059 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7060 plumbing_response.rate_limit) 7061 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7062 plumbing_response.secret_engine) 7063 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7065 def update(self, secret_engine, timeout=None): 7066 ''' 7067 Update updates a secret engine 7068 ''' 7069 deadline = None if timeout is None else time.time() + timeout 7070 req = SecretEngineUpdateRequest() 7071 7072 if secret_engine is not None: 7073 req.secret_engine.CopyFrom( 7074 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7075 tries = 0 7076 plumbing_response = None 7077 while True: 7078 t = None if deadline is None else deadline - time.time() 7079 try: 7080 plumbing_response = self.stub.Update( 7081 req, 7082 metadata=self.parent.get_metadata('SecretEngines.Update', 7083 req), 7084 timeout=t) 7085 except Exception as e: 7086 if self.parent.shouldRetry(tries, e, deadline): 7087 tries += 1 7088 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7089 continue 7090 raise plumbing.convert_error_to_porcelain(e) from e 7091 break 7092 7093 resp = models.SecretEngineUpdateResponse() 7094 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7095 plumbing_response.meta) 7096 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7097 plumbing_response.rate_limit) 7098 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7099 plumbing_response.secret_engine) 7100 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7102 def delete(self, id, timeout=None): 7103 ''' 7104 Delete deletes a secret engine 7105 ''' 7106 deadline = None if timeout is None else time.time() + timeout 7107 req = SecretEngineDeleteRequest() 7108 7109 req.id = (id) 7110 tries = 0 7111 plumbing_response = None 7112 while True: 7113 t = None if deadline is None else deadline - time.time() 7114 try: 7115 plumbing_response = self.stub.Delete( 7116 req, 7117 metadata=self.parent.get_metadata('SecretEngines.Delete', 7118 req), 7119 timeout=t) 7120 except Exception as e: 7121 if self.parent.shouldRetry(tries, e, deadline): 7122 tries += 1 7123 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7124 continue 7125 raise plumbing.convert_error_to_porcelain(e) from e 7126 break 7127 7128 resp = models.SecretEngineDeleteResponse() 7129 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7130 plumbing_response.rate_limit) 7131 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
7133 def list_secret_stores(self, filter, *args, timeout=None): 7134 ''' 7135 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7136 for Secret Engine 7137 ''' 7138 deadline = None if timeout is None else time.time() + timeout 7139 req = SecretStoreListRequest() 7140 req.meta.CopyFrom(ListRequestMetadata()) 7141 if self.parent.page_limit > 0: 7142 req.meta.limit = self.parent.page_limit 7143 if self.parent.snapshot_datetime is not None: 7144 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7145 7146 req.filter = plumbing.quote_filter_args(filter, *args) 7147 7148 def generator(svc, req): 7149 tries = 0 7150 while True: 7151 t = None if deadline is None else deadline - time.time() 7152 try: 7153 plumbing_response = svc.stub.ListSecretStores( 7154 req, 7155 metadata=svc.parent.get_metadata( 7156 'SecretEngines.ListSecretStores', req), 7157 timeout=t) 7158 except Exception as e: 7159 if self.parent.shouldRetry(tries, e, deadline): 7160 tries += 1 7161 time.sleep( 7162 self.parent.exponentialBackoff(tries, deadline)) 7163 continue 7164 raise plumbing.convert_error_to_porcelain(e) from e 7165 tries = 0 7166 for plumbing_item in plumbing_response.secret_stores: 7167 yield plumbing.convert_secret_store_to_porcelain( 7168 plumbing_item) 7169 if plumbing_response.meta.next_cursor == '': 7170 break 7171 req.meta.cursor = plumbing_response.meta.next_cursor 7172 7173 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)
7175 def generate_keys(self, secret_engine_id, timeout=None): 7176 ''' 7177 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7178 ''' 7179 deadline = None if timeout is None else time.time() + timeout 7180 req = GenerateKeysRequest() 7181 7182 req.secret_engine_id = (secret_engine_id) 7183 tries = 0 7184 plumbing_response = None 7185 while True: 7186 t = None if deadline is None else deadline - time.time() 7187 try: 7188 plumbing_response = self.stub.GenerateKeys( 7189 req, 7190 metadata=self.parent.get_metadata( 7191 'SecretEngines.GenerateKeys', req), 7192 timeout=t) 7193 except Exception as e: 7194 if self.parent.shouldRetry(tries, e, deadline): 7195 tries += 1 7196 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7197 continue 7198 raise plumbing.convert_error_to_porcelain(e) from e 7199 break 7200 7201 resp = models.GenerateKeysResponse() 7202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7203 plumbing_response.rate_limit) 7204 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)
7206 def healthcheck(self, secret_engine_id, timeout=None): 7207 ''' 7208 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7209 ''' 7210 deadline = None if timeout is None else time.time() + timeout 7211 req = HealthcheckRequest() 7212 7213 req.secret_engine_id = (secret_engine_id) 7214 tries = 0 7215 plumbing_response = None 7216 while True: 7217 t = None if deadline is None else deadline - time.time() 7218 try: 7219 plumbing_response = self.stub.Healthcheck( 7220 req, 7221 metadata=self.parent.get_metadata( 7222 'SecretEngines.Healthcheck', req), 7223 timeout=t) 7224 except Exception as e: 7225 if self.parent.shouldRetry(tries, e, deadline): 7226 tries += 1 7227 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7228 continue 7229 raise plumbing.convert_error_to_porcelain(e) from e 7230 break 7231 7232 resp = models.HealthcheckResponse() 7233 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7234 plumbing_response.rate_limit) 7235 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7236 plumbing_response.status) 7237 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
7239 def rotate(self, id, password_policy, timeout=None): 7240 ''' 7241 Rotate rotates secret engine's credentials 7242 ''' 7243 deadline = None if timeout is None else time.time() + timeout 7244 req = SecretEngineRotateRequest() 7245 7246 req.id = (id) 7247 if password_policy is not None: 7248 req.password_policy.CopyFrom( 7249 plumbing.convert_secret_engine_password_policy_to_plumbing( 7250 password_policy)) 7251 tries = 0 7252 plumbing_response = None 7253 while True: 7254 t = None if deadline is None else deadline - time.time() 7255 try: 7256 plumbing_response = self.stub.Rotate( 7257 req, 7258 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7259 req), 7260 timeout=t) 7261 except Exception as e: 7262 if self.parent.shouldRetry(tries, e, deadline): 7263 tries += 1 7264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7265 continue 7266 raise plumbing.convert_error_to_porcelain(e) from e 7267 break 7268 7269 resp = models.SecretEngineRotateResponse() 7270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7271 plumbing_response.rate_limit) 7272 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
7275class SecretStoreHealths: 7276 ''' 7277 SecretStoreHealths exposes health states for secret stores. 7278 See `strongdm.models.SecretStoreHealth`. 7279 ''' 7280 def __init__(self, channel, client): 7281 self.parent = client 7282 self.stub = SecretStoreHealthsStub(channel) 7283 7284 def list(self, filter, *args, timeout=None): 7285 ''' 7286 List reports the health status of node to secret store pairs. 7287 ''' 7288 deadline = None if timeout is None else time.time() + timeout 7289 req = SecretStoreHealthListRequest() 7290 req.meta.CopyFrom(ListRequestMetadata()) 7291 if self.parent.page_limit > 0: 7292 req.meta.limit = self.parent.page_limit 7293 if self.parent.snapshot_datetime is not None: 7294 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7295 7296 req.filter = plumbing.quote_filter_args(filter, *args) 7297 7298 def generator(svc, req): 7299 tries = 0 7300 while True: 7301 t = None if deadline is None else deadline - time.time() 7302 try: 7303 plumbing_response = svc.stub.List( 7304 req, 7305 metadata=svc.parent.get_metadata( 7306 'SecretStoreHealths.List', req), 7307 timeout=t) 7308 except Exception as e: 7309 if self.parent.shouldRetry(tries, e, deadline): 7310 tries += 1 7311 time.sleep( 7312 self.parent.exponentialBackoff(tries, deadline)) 7313 continue 7314 raise plumbing.convert_error_to_porcelain(e) from e 7315 tries = 0 7316 for plumbing_item in plumbing_response.secret_store_healths: 7317 yield plumbing.convert_secret_store_health_to_porcelain( 7318 plumbing_item) 7319 if plumbing_response.meta.next_cursor == '': 7320 break 7321 req.meta.cursor = plumbing_response.meta.next_cursor 7322 7323 return generator(self, req) 7324 7325 def healthcheck(self, secret_store_id, timeout=None): 7326 ''' 7327 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7328 to propagate across a large network of Nodes. The call will return immediately, and the 7329 updated health of the Secret Store can be retrieved via List. 7330 ''' 7331 deadline = None if timeout is None else time.time() + timeout 7332 req = SecretStoreHealthcheckRequest() 7333 7334 req.secret_store_id = (secret_store_id) 7335 tries = 0 7336 plumbing_response = None 7337 while True: 7338 t = None if deadline is None else deadline - time.time() 7339 try: 7340 plumbing_response = self.stub.Healthcheck( 7341 req, 7342 metadata=self.parent.get_metadata( 7343 'SecretStoreHealths.Healthcheck', req), 7344 timeout=t) 7345 except Exception as e: 7346 if self.parent.shouldRetry(tries, e, deadline): 7347 tries += 1 7348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7349 continue 7350 raise plumbing.convert_error_to_porcelain(e) from e 7351 break 7352 7353 resp = models.SecretStoreHealthcheckResponse() 7354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7355 plumbing_response.rate_limit) 7356 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
7284 def list(self, filter, *args, timeout=None): 7285 ''' 7286 List reports the health status of node to secret store pairs. 7287 ''' 7288 deadline = None if timeout is None else time.time() + timeout 7289 req = SecretStoreHealthListRequest() 7290 req.meta.CopyFrom(ListRequestMetadata()) 7291 if self.parent.page_limit > 0: 7292 req.meta.limit = self.parent.page_limit 7293 if self.parent.snapshot_datetime is not None: 7294 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7295 7296 req.filter = plumbing.quote_filter_args(filter, *args) 7297 7298 def generator(svc, req): 7299 tries = 0 7300 while True: 7301 t = None if deadline is None else deadline - time.time() 7302 try: 7303 plumbing_response = svc.stub.List( 7304 req, 7305 metadata=svc.parent.get_metadata( 7306 'SecretStoreHealths.List', req), 7307 timeout=t) 7308 except Exception as e: 7309 if self.parent.shouldRetry(tries, e, deadline): 7310 tries += 1 7311 time.sleep( 7312 self.parent.exponentialBackoff(tries, deadline)) 7313 continue 7314 raise plumbing.convert_error_to_porcelain(e) from e 7315 tries = 0 7316 for plumbing_item in plumbing_response.secret_store_healths: 7317 yield plumbing.convert_secret_store_health_to_porcelain( 7318 plumbing_item) 7319 if plumbing_response.meta.next_cursor == '': 7320 break 7321 req.meta.cursor = plumbing_response.meta.next_cursor 7322 7323 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
7325 def healthcheck(self, secret_store_id, timeout=None): 7326 ''' 7327 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7328 to propagate across a large network of Nodes. The call will return immediately, and the 7329 updated health of the Secret Store can be retrieved via List. 7330 ''' 7331 deadline = None if timeout is None else time.time() + timeout 7332 req = SecretStoreHealthcheckRequest() 7333 7334 req.secret_store_id = (secret_store_id) 7335 tries = 0 7336 plumbing_response = None 7337 while True: 7338 t = None if deadline is None else deadline - time.time() 7339 try: 7340 plumbing_response = self.stub.Healthcheck( 7341 req, 7342 metadata=self.parent.get_metadata( 7343 'SecretStoreHealths.Healthcheck', req), 7344 timeout=t) 7345 except Exception as e: 7346 if self.parent.shouldRetry(tries, e, deadline): 7347 tries += 1 7348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7349 continue 7350 raise plumbing.convert_error_to_porcelain(e) from e 7351 break 7352 7353 resp = models.SecretStoreHealthcheckResponse() 7354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7355 plumbing_response.rate_limit) 7356 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:
7359class SecretStoresHistory: 7360 ''' 7361 SecretStoresHistory records all changes to the state of a SecretStore. 7362 See `strongdm.models.SecretStoreHistory`. 7363 ''' 7364 def __init__(self, channel, client): 7365 self.parent = client 7366 self.stub = SecretStoresHistoryStub(channel) 7367 7368 def list(self, filter, *args, timeout=None): 7369 ''' 7370 List gets a list of SecretStoreHistory records matching a given set of criteria. 7371 ''' 7372 deadline = None if timeout is None else time.time() + timeout 7373 req = SecretStoreHistoryListRequest() 7374 req.meta.CopyFrom(ListRequestMetadata()) 7375 if self.parent.page_limit > 0: 7376 req.meta.limit = self.parent.page_limit 7377 if self.parent.snapshot_datetime is not None: 7378 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7379 7380 req.filter = plumbing.quote_filter_args(filter, *args) 7381 7382 def generator(svc, req): 7383 tries = 0 7384 while True: 7385 t = None if deadline is None else deadline - time.time() 7386 try: 7387 plumbing_response = svc.stub.List( 7388 req, 7389 metadata=svc.parent.get_metadata( 7390 'SecretStoresHistory.List', req), 7391 timeout=t) 7392 except Exception as e: 7393 if self.parent.shouldRetry(tries, e, deadline): 7394 tries += 1 7395 time.sleep( 7396 self.parent.exponentialBackoff(tries, deadline)) 7397 continue 7398 raise plumbing.convert_error_to_porcelain(e) from e 7399 tries = 0 7400 for plumbing_item in plumbing_response.history: 7401 yield plumbing.convert_secret_store_history_to_porcelain( 7402 plumbing_item) 7403 if plumbing_response.meta.next_cursor == '': 7404 break 7405 req.meta.cursor = plumbing_response.meta.next_cursor 7406 7407 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)
7368 def list(self, filter, *args, timeout=None): 7369 ''' 7370 List gets a list of SecretStoreHistory records matching a given set of criteria. 7371 ''' 7372 deadline = None if timeout is None else time.time() + timeout 7373 req = SecretStoreHistoryListRequest() 7374 req.meta.CopyFrom(ListRequestMetadata()) 7375 if self.parent.page_limit > 0: 7376 req.meta.limit = self.parent.page_limit 7377 if self.parent.snapshot_datetime is not None: 7378 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7379 7380 req.filter = plumbing.quote_filter_args(filter, *args) 7381 7382 def generator(svc, req): 7383 tries = 0 7384 while True: 7385 t = None if deadline is None else deadline - time.time() 7386 try: 7387 plumbing_response = svc.stub.List( 7388 req, 7389 metadata=svc.parent.get_metadata( 7390 'SecretStoresHistory.List', req), 7391 timeout=t) 7392 except Exception as e: 7393 if self.parent.shouldRetry(tries, e, deadline): 7394 tries += 1 7395 time.sleep( 7396 self.parent.exponentialBackoff(tries, deadline)) 7397 continue 7398 raise plumbing.convert_error_to_porcelain(e) from e 7399 tries = 0 7400 for plumbing_item in plumbing_response.history: 7401 yield plumbing.convert_secret_store_history_to_porcelain( 7402 plumbing_item) 7403 if plumbing_response.meta.next_cursor == '': 7404 break 7405 req.meta.cursor = plumbing_response.meta.next_cursor 7406 7407 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
7410class WorkflowApprovers: 7411 ''' 7412 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7413 See `strongdm.models.WorkflowApprover`. 7414 ''' 7415 def __init__(self, channel, client): 7416 self.parent = client 7417 self.stub = WorkflowApproversStub(channel) 7418 7419 def create(self, workflow_approver, timeout=None): 7420 ''' 7421 Create creates a new workflow approver 7422 ''' 7423 deadline = None if timeout is None else time.time() + timeout 7424 req = WorkflowApproversCreateRequest() 7425 7426 if workflow_approver is not None: 7427 req.workflow_approver.CopyFrom( 7428 plumbing.convert_workflow_approver_to_plumbing( 7429 workflow_approver)) 7430 tries = 0 7431 plumbing_response = None 7432 while True: 7433 t = None if deadline is None else deadline - time.time() 7434 try: 7435 plumbing_response = self.stub.Create( 7436 req, 7437 metadata=self.parent.get_metadata( 7438 'WorkflowApprovers.Create', req), 7439 timeout=t) 7440 except Exception as e: 7441 if self.parent.shouldRetry(tries, e, deadline): 7442 tries += 1 7443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7444 continue 7445 raise plumbing.convert_error_to_porcelain(e) from e 7446 break 7447 7448 resp = models.WorkflowApproversCreateResponse() 7449 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7450 plumbing_response.rate_limit) 7451 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7452 plumbing_response.workflow_approver) 7453 return resp 7454 7455 def get(self, id, timeout=None): 7456 ''' 7457 Get reads one workflow approver by ID. 7458 ''' 7459 deadline = None if timeout is None else time.time() + timeout 7460 req = WorkflowApproverGetRequest() 7461 if self.parent.snapshot_datetime is not None: 7462 req.meta.CopyFrom(GetRequestMetadata()) 7463 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7464 7465 req.id = (id) 7466 tries = 0 7467 plumbing_response = None 7468 while True: 7469 t = None if deadline is None else deadline - time.time() 7470 try: 7471 plumbing_response = self.stub.Get( 7472 req, 7473 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7474 req), 7475 timeout=t) 7476 except Exception as e: 7477 if self.parent.shouldRetry(tries, e, deadline): 7478 tries += 1 7479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7480 continue 7481 raise plumbing.convert_error_to_porcelain(e) from e 7482 break 7483 7484 resp = models.WorkflowApproverGetResponse() 7485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7486 plumbing_response.meta) 7487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7488 plumbing_response.rate_limit) 7489 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7490 plumbing_response.workflow_approver) 7491 return resp 7492 7493 def delete(self, id, timeout=None): 7494 ''' 7495 Delete deletes a workflow approver 7496 ''' 7497 deadline = None if timeout is None else time.time() + timeout 7498 req = WorkflowApproversDeleteRequest() 7499 7500 req.id = (id) 7501 tries = 0 7502 plumbing_response = None 7503 while True: 7504 t = None if deadline is None else deadline - time.time() 7505 try: 7506 plumbing_response = self.stub.Delete( 7507 req, 7508 metadata=self.parent.get_metadata( 7509 'WorkflowApprovers.Delete', req), 7510 timeout=t) 7511 except Exception as e: 7512 if self.parent.shouldRetry(tries, e, deadline): 7513 tries += 1 7514 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7515 continue 7516 raise plumbing.convert_error_to_porcelain(e) from e 7517 break 7518 7519 resp = models.WorkflowApproversDeleteResponse() 7520 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7521 plumbing_response.rate_limit) 7522 return resp 7523 7524 def list(self, filter, *args, timeout=None): 7525 ''' 7526 Lists existing workflow approvers. 7527 ''' 7528 deadline = None if timeout is None else time.time() + timeout 7529 req = WorkflowApproversListRequest() 7530 req.meta.CopyFrom(ListRequestMetadata()) 7531 if self.parent.page_limit > 0: 7532 req.meta.limit = self.parent.page_limit 7533 if self.parent.snapshot_datetime is not None: 7534 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7535 7536 req.filter = plumbing.quote_filter_args(filter, *args) 7537 7538 def generator(svc, req): 7539 tries = 0 7540 while True: 7541 t = None if deadline is None else deadline - time.time() 7542 try: 7543 plumbing_response = svc.stub.List( 7544 req, 7545 metadata=svc.parent.get_metadata( 7546 'WorkflowApprovers.List', req), 7547 timeout=t) 7548 except Exception as e: 7549 if self.parent.shouldRetry(tries, e, deadline): 7550 tries += 1 7551 time.sleep( 7552 self.parent.exponentialBackoff(tries, deadline)) 7553 continue 7554 raise plumbing.convert_error_to_porcelain(e) from e 7555 tries = 0 7556 for plumbing_item in plumbing_response.workflow_approvers: 7557 yield plumbing.convert_workflow_approver_to_porcelain( 7558 plumbing_item) 7559 if plumbing_response.meta.next_cursor == '': 7560 break 7561 req.meta.cursor = plumbing_response.meta.next_cursor 7562 7563 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)
7419 def create(self, workflow_approver, timeout=None): 7420 ''' 7421 Create creates a new workflow approver 7422 ''' 7423 deadline = None if timeout is None else time.time() + timeout 7424 req = WorkflowApproversCreateRequest() 7425 7426 if workflow_approver is not None: 7427 req.workflow_approver.CopyFrom( 7428 plumbing.convert_workflow_approver_to_plumbing( 7429 workflow_approver)) 7430 tries = 0 7431 plumbing_response = None 7432 while True: 7433 t = None if deadline is None else deadline - time.time() 7434 try: 7435 plumbing_response = self.stub.Create( 7436 req, 7437 metadata=self.parent.get_metadata( 7438 'WorkflowApprovers.Create', req), 7439 timeout=t) 7440 except Exception as e: 7441 if self.parent.shouldRetry(tries, e, deadline): 7442 tries += 1 7443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7444 continue 7445 raise plumbing.convert_error_to_porcelain(e) from e 7446 break 7447 7448 resp = models.WorkflowApproversCreateResponse() 7449 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7450 plumbing_response.rate_limit) 7451 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7452 plumbing_response.workflow_approver) 7453 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
7455 def get(self, id, timeout=None): 7456 ''' 7457 Get reads one workflow approver by ID. 7458 ''' 7459 deadline = None if timeout is None else time.time() + timeout 7460 req = WorkflowApproverGetRequest() 7461 if self.parent.snapshot_datetime is not None: 7462 req.meta.CopyFrom(GetRequestMetadata()) 7463 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7464 7465 req.id = (id) 7466 tries = 0 7467 plumbing_response = None 7468 while True: 7469 t = None if deadline is None else deadline - time.time() 7470 try: 7471 plumbing_response = self.stub.Get( 7472 req, 7473 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7474 req), 7475 timeout=t) 7476 except Exception as e: 7477 if self.parent.shouldRetry(tries, e, deadline): 7478 tries += 1 7479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7480 continue 7481 raise plumbing.convert_error_to_porcelain(e) from e 7482 break 7483 7484 resp = models.WorkflowApproverGetResponse() 7485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7486 plumbing_response.meta) 7487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7488 plumbing_response.rate_limit) 7489 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7490 plumbing_response.workflow_approver) 7491 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
7493 def delete(self, id, timeout=None): 7494 ''' 7495 Delete deletes a workflow approver 7496 ''' 7497 deadline = None if timeout is None else time.time() + timeout 7498 req = WorkflowApproversDeleteRequest() 7499 7500 req.id = (id) 7501 tries = 0 7502 plumbing_response = None 7503 while True: 7504 t = None if deadline is None else deadline - time.time() 7505 try: 7506 plumbing_response = self.stub.Delete( 7507 req, 7508 metadata=self.parent.get_metadata( 7509 'WorkflowApprovers.Delete', req), 7510 timeout=t) 7511 except Exception as e: 7512 if self.parent.shouldRetry(tries, e, deadline): 7513 tries += 1 7514 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7515 continue 7516 raise plumbing.convert_error_to_porcelain(e) from e 7517 break 7518 7519 resp = models.WorkflowApproversDeleteResponse() 7520 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7521 plumbing_response.rate_limit) 7522 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
7524 def list(self, filter, *args, timeout=None): 7525 ''' 7526 Lists existing workflow approvers. 7527 ''' 7528 deadline = None if timeout is None else time.time() + timeout 7529 req = WorkflowApproversListRequest() 7530 req.meta.CopyFrom(ListRequestMetadata()) 7531 if self.parent.page_limit > 0: 7532 req.meta.limit = self.parent.page_limit 7533 if self.parent.snapshot_datetime is not None: 7534 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7535 7536 req.filter = plumbing.quote_filter_args(filter, *args) 7537 7538 def generator(svc, req): 7539 tries = 0 7540 while True: 7541 t = None if deadline is None else deadline - time.time() 7542 try: 7543 plumbing_response = svc.stub.List( 7544 req, 7545 metadata=svc.parent.get_metadata( 7546 'WorkflowApprovers.List', req), 7547 timeout=t) 7548 except Exception as e: 7549 if self.parent.shouldRetry(tries, e, deadline): 7550 tries += 1 7551 time.sleep( 7552 self.parent.exponentialBackoff(tries, deadline)) 7553 continue 7554 raise plumbing.convert_error_to_porcelain(e) from e 7555 tries = 0 7556 for plumbing_item in plumbing_response.workflow_approvers: 7557 yield plumbing.convert_workflow_approver_to_porcelain( 7558 plumbing_item) 7559 if plumbing_response.meta.next_cursor == '': 7560 break 7561 req.meta.cursor = plumbing_response.meta.next_cursor 7562 7563 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
7566class SnapshotWorkflowApprovers: 7567 ''' 7568 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7569 service for historical queries. 7570 ''' 7571 def __init__(self, workflow_approvers): 7572 self.workflow_approvers = workflow_approvers 7573 7574 def get(self, id, timeout=None): 7575 ''' 7576 Get reads one workflow approver by ID. 7577 ''' 7578 return self.workflow_approvers.get(id, timeout=timeout) 7579 7580 def list(self, filter, *args, timeout=None): 7581 ''' 7582 Lists existing workflow approvers. 7583 ''' 7584 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
7587class WorkflowApproversHistory: 7588 ''' 7589 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7590 See `strongdm.models.WorkflowApproverHistory`. 7591 ''' 7592 def __init__(self, channel, client): 7593 self.parent = client 7594 self.stub = WorkflowApproversHistoryStub(channel) 7595 7596 def list(self, filter, *args, timeout=None): 7597 ''' 7598 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7599 ''' 7600 deadline = None if timeout is None else time.time() + timeout 7601 req = WorkflowApproversHistoryListRequest() 7602 req.meta.CopyFrom(ListRequestMetadata()) 7603 if self.parent.page_limit > 0: 7604 req.meta.limit = self.parent.page_limit 7605 if self.parent.snapshot_datetime is not None: 7606 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7607 7608 req.filter = plumbing.quote_filter_args(filter, *args) 7609 7610 def generator(svc, req): 7611 tries = 0 7612 while True: 7613 t = None if deadline is None else deadline - time.time() 7614 try: 7615 plumbing_response = svc.stub.List( 7616 req, 7617 metadata=svc.parent.get_metadata( 7618 'WorkflowApproversHistory.List', req), 7619 timeout=t) 7620 except Exception as e: 7621 if self.parent.shouldRetry(tries, e, deadline): 7622 tries += 1 7623 time.sleep( 7624 self.parent.exponentialBackoff(tries, deadline)) 7625 continue 7626 raise plumbing.convert_error_to_porcelain(e) from e 7627 tries = 0 7628 for plumbing_item in plumbing_response.history: 7629 yield plumbing.convert_workflow_approver_history_to_porcelain( 7630 plumbing_item) 7631 if plumbing_response.meta.next_cursor == '': 7632 break 7633 req.meta.cursor = plumbing_response.meta.next_cursor 7634 7635 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)
7596 def list(self, filter, *args, timeout=None): 7597 ''' 7598 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7599 ''' 7600 deadline = None if timeout is None else time.time() + timeout 7601 req = WorkflowApproversHistoryListRequest() 7602 req.meta.CopyFrom(ListRequestMetadata()) 7603 if self.parent.page_limit > 0: 7604 req.meta.limit = self.parent.page_limit 7605 if self.parent.snapshot_datetime is not None: 7606 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7607 7608 req.filter = plumbing.quote_filter_args(filter, *args) 7609 7610 def generator(svc, req): 7611 tries = 0 7612 while True: 7613 t = None if deadline is None else deadline - time.time() 7614 try: 7615 plumbing_response = svc.stub.List( 7616 req, 7617 metadata=svc.parent.get_metadata( 7618 'WorkflowApproversHistory.List', req), 7619 timeout=t) 7620 except Exception as e: 7621 if self.parent.shouldRetry(tries, e, deadline): 7622 tries += 1 7623 time.sleep( 7624 self.parent.exponentialBackoff(tries, deadline)) 7625 continue 7626 raise plumbing.convert_error_to_porcelain(e) from e 7627 tries = 0 7628 for plumbing_item in plumbing_response.history: 7629 yield plumbing.convert_workflow_approver_history_to_porcelain( 7630 plumbing_item) 7631 if plumbing_response.meta.next_cursor == '': 7632 break 7633 req.meta.cursor = plumbing_response.meta.next_cursor 7634 7635 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
7638class WorkflowRoles: 7639 ''' 7640 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7641 to request access to a resource via the workflow. 7642 See `strongdm.models.WorkflowRole`. 7643 ''' 7644 def __init__(self, channel, client): 7645 self.parent = client 7646 self.stub = WorkflowRolesStub(channel) 7647 7648 def create(self, workflow_role, timeout=None): 7649 ''' 7650 Create creates a new workflow role 7651 ''' 7652 deadline = None if timeout is None else time.time() + timeout 7653 req = WorkflowRolesCreateRequest() 7654 7655 if workflow_role is not None: 7656 req.workflow_role.CopyFrom( 7657 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7658 tries = 0 7659 plumbing_response = None 7660 while True: 7661 t = None if deadline is None else deadline - time.time() 7662 try: 7663 plumbing_response = self.stub.Create( 7664 req, 7665 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7666 req), 7667 timeout=t) 7668 except Exception as e: 7669 if self.parent.shouldRetry(tries, e, deadline): 7670 tries += 1 7671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7672 continue 7673 raise plumbing.convert_error_to_porcelain(e) from e 7674 break 7675 7676 resp = models.WorkflowRolesCreateResponse() 7677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7678 plumbing_response.rate_limit) 7679 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7680 plumbing_response.workflow_role) 7681 return resp 7682 7683 def get(self, id, timeout=None): 7684 ''' 7685 Get reads one workflow role by ID. 7686 ''' 7687 deadline = None if timeout is None else time.time() + timeout 7688 req = WorkflowRoleGetRequest() 7689 if self.parent.snapshot_datetime is not None: 7690 req.meta.CopyFrom(GetRequestMetadata()) 7691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7692 7693 req.id = (id) 7694 tries = 0 7695 plumbing_response = None 7696 while True: 7697 t = None if deadline is None else deadline - time.time() 7698 try: 7699 plumbing_response = self.stub.Get( 7700 req, 7701 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7702 req), 7703 timeout=t) 7704 except Exception as e: 7705 if self.parent.shouldRetry(tries, e, deadline): 7706 tries += 1 7707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7708 continue 7709 raise plumbing.convert_error_to_porcelain(e) from e 7710 break 7711 7712 resp = models.WorkflowRoleGetResponse() 7713 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7714 plumbing_response.meta) 7715 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7716 plumbing_response.rate_limit) 7717 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7718 plumbing_response.workflow_role) 7719 return resp 7720 7721 def delete(self, id, timeout=None): 7722 ''' 7723 Delete deletes a workflow role 7724 ''' 7725 deadline = None if timeout is None else time.time() + timeout 7726 req = WorkflowRolesDeleteRequest() 7727 7728 req.id = (id) 7729 tries = 0 7730 plumbing_response = None 7731 while True: 7732 t = None if deadline is None else deadline - time.time() 7733 try: 7734 plumbing_response = self.stub.Delete( 7735 req, 7736 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7737 req), 7738 timeout=t) 7739 except Exception as e: 7740 if self.parent.shouldRetry(tries, e, deadline): 7741 tries += 1 7742 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7743 continue 7744 raise plumbing.convert_error_to_porcelain(e) from e 7745 break 7746 7747 resp = models.WorkflowRolesDeleteResponse() 7748 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7749 plumbing_response.rate_limit) 7750 return resp 7751 7752 def list(self, filter, *args, timeout=None): 7753 ''' 7754 Lists existing workflow roles. 7755 ''' 7756 deadline = None if timeout is None else time.time() + timeout 7757 req = WorkflowRolesListRequest() 7758 req.meta.CopyFrom(ListRequestMetadata()) 7759 if self.parent.page_limit > 0: 7760 req.meta.limit = self.parent.page_limit 7761 if self.parent.snapshot_datetime is not None: 7762 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7763 7764 req.filter = plumbing.quote_filter_args(filter, *args) 7765 7766 def generator(svc, req): 7767 tries = 0 7768 while True: 7769 t = None if deadline is None else deadline - time.time() 7770 try: 7771 plumbing_response = svc.stub.List( 7772 req, 7773 metadata=svc.parent.get_metadata( 7774 'WorkflowRoles.List', req), 7775 timeout=t) 7776 except Exception as e: 7777 if self.parent.shouldRetry(tries, e, deadline): 7778 tries += 1 7779 time.sleep( 7780 self.parent.exponentialBackoff(tries, deadline)) 7781 continue 7782 raise plumbing.convert_error_to_porcelain(e) from e 7783 tries = 0 7784 for plumbing_item in plumbing_response.workflow_role: 7785 yield plumbing.convert_workflow_role_to_porcelain( 7786 plumbing_item) 7787 if plumbing_response.meta.next_cursor == '': 7788 break 7789 req.meta.cursor = plumbing_response.meta.next_cursor 7790 7791 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)
7648 def create(self, workflow_role, timeout=None): 7649 ''' 7650 Create creates a new workflow role 7651 ''' 7652 deadline = None if timeout is None else time.time() + timeout 7653 req = WorkflowRolesCreateRequest() 7654 7655 if workflow_role is not None: 7656 req.workflow_role.CopyFrom( 7657 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7658 tries = 0 7659 plumbing_response = None 7660 while True: 7661 t = None if deadline is None else deadline - time.time() 7662 try: 7663 plumbing_response = self.stub.Create( 7664 req, 7665 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7666 req), 7667 timeout=t) 7668 except Exception as e: 7669 if self.parent.shouldRetry(tries, e, deadline): 7670 tries += 1 7671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7672 continue 7673 raise plumbing.convert_error_to_porcelain(e) from e 7674 break 7675 7676 resp = models.WorkflowRolesCreateResponse() 7677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7678 plumbing_response.rate_limit) 7679 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7680 plumbing_response.workflow_role) 7681 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
7683 def get(self, id, timeout=None): 7684 ''' 7685 Get reads one workflow role by ID. 7686 ''' 7687 deadline = None if timeout is None else time.time() + timeout 7688 req = WorkflowRoleGetRequest() 7689 if self.parent.snapshot_datetime is not None: 7690 req.meta.CopyFrom(GetRequestMetadata()) 7691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7692 7693 req.id = (id) 7694 tries = 0 7695 plumbing_response = None 7696 while True: 7697 t = None if deadline is None else deadline - time.time() 7698 try: 7699 plumbing_response = self.stub.Get( 7700 req, 7701 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7702 req), 7703 timeout=t) 7704 except Exception as e: 7705 if self.parent.shouldRetry(tries, e, deadline): 7706 tries += 1 7707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7708 continue 7709 raise plumbing.convert_error_to_porcelain(e) from e 7710 break 7711 7712 resp = models.WorkflowRoleGetResponse() 7713 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7714 plumbing_response.meta) 7715 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7716 plumbing_response.rate_limit) 7717 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7718 plumbing_response.workflow_role) 7719 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
7721 def delete(self, id, timeout=None): 7722 ''' 7723 Delete deletes a workflow role 7724 ''' 7725 deadline = None if timeout is None else time.time() + timeout 7726 req = WorkflowRolesDeleteRequest() 7727 7728 req.id = (id) 7729 tries = 0 7730 plumbing_response = None 7731 while True: 7732 t = None if deadline is None else deadline - time.time() 7733 try: 7734 plumbing_response = self.stub.Delete( 7735 req, 7736 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7737 req), 7738 timeout=t) 7739 except Exception as e: 7740 if self.parent.shouldRetry(tries, e, deadline): 7741 tries += 1 7742 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7743 continue 7744 raise plumbing.convert_error_to_porcelain(e) from e 7745 break 7746 7747 resp = models.WorkflowRolesDeleteResponse() 7748 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7749 plumbing_response.rate_limit) 7750 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
7752 def list(self, filter, *args, timeout=None): 7753 ''' 7754 Lists existing workflow roles. 7755 ''' 7756 deadline = None if timeout is None else time.time() + timeout 7757 req = WorkflowRolesListRequest() 7758 req.meta.CopyFrom(ListRequestMetadata()) 7759 if self.parent.page_limit > 0: 7760 req.meta.limit = self.parent.page_limit 7761 if self.parent.snapshot_datetime is not None: 7762 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7763 7764 req.filter = plumbing.quote_filter_args(filter, *args) 7765 7766 def generator(svc, req): 7767 tries = 0 7768 while True: 7769 t = None if deadline is None else deadline - time.time() 7770 try: 7771 plumbing_response = svc.stub.List( 7772 req, 7773 metadata=svc.parent.get_metadata( 7774 'WorkflowRoles.List', req), 7775 timeout=t) 7776 except Exception as e: 7777 if self.parent.shouldRetry(tries, e, deadline): 7778 tries += 1 7779 time.sleep( 7780 self.parent.exponentialBackoff(tries, deadline)) 7781 continue 7782 raise plumbing.convert_error_to_porcelain(e) from e 7783 tries = 0 7784 for plumbing_item in plumbing_response.workflow_role: 7785 yield plumbing.convert_workflow_role_to_porcelain( 7786 plumbing_item) 7787 if plumbing_response.meta.next_cursor == '': 7788 break 7789 req.meta.cursor = plumbing_response.meta.next_cursor 7790 7791 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
7794class SnapshotWorkflowRoles: 7795 ''' 7796 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7797 service for historical queries. 7798 ''' 7799 def __init__(self, workflow_roles): 7800 self.workflow_roles = workflow_roles 7801 7802 def get(self, id, timeout=None): 7803 ''' 7804 Get reads one workflow role by ID. 7805 ''' 7806 return self.workflow_roles.get(id, timeout=timeout) 7807 7808 def list(self, filter, *args, timeout=None): 7809 ''' 7810 Lists existing workflow roles. 7811 ''' 7812 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
7815class WorkflowRolesHistory: 7816 ''' 7817 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7818 See `strongdm.models.WorkflowRoleHistory`. 7819 ''' 7820 def __init__(self, channel, client): 7821 self.parent = client 7822 self.stub = WorkflowRolesHistoryStub(channel) 7823 7824 def list(self, filter, *args, timeout=None): 7825 ''' 7826 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7827 ''' 7828 deadline = None if timeout is None else time.time() + timeout 7829 req = WorkflowRolesHistoryListRequest() 7830 req.meta.CopyFrom(ListRequestMetadata()) 7831 if self.parent.page_limit > 0: 7832 req.meta.limit = self.parent.page_limit 7833 if self.parent.snapshot_datetime is not None: 7834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7835 7836 req.filter = plumbing.quote_filter_args(filter, *args) 7837 7838 def generator(svc, req): 7839 tries = 0 7840 while True: 7841 t = None if deadline is None else deadline - time.time() 7842 try: 7843 plumbing_response = svc.stub.List( 7844 req, 7845 metadata=svc.parent.get_metadata( 7846 'WorkflowRolesHistory.List', req), 7847 timeout=t) 7848 except Exception as e: 7849 if self.parent.shouldRetry(tries, e, deadline): 7850 tries += 1 7851 time.sleep( 7852 self.parent.exponentialBackoff(tries, deadline)) 7853 continue 7854 raise plumbing.convert_error_to_porcelain(e) from e 7855 tries = 0 7856 for plumbing_item in plumbing_response.history: 7857 yield plumbing.convert_workflow_role_history_to_porcelain( 7858 plumbing_item) 7859 if plumbing_response.meta.next_cursor == '': 7860 break 7861 req.meta.cursor = plumbing_response.meta.next_cursor 7862 7863 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)
7824 def list(self, filter, *args, timeout=None): 7825 ''' 7826 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7827 ''' 7828 deadline = None if timeout is None else time.time() + timeout 7829 req = WorkflowRolesHistoryListRequest() 7830 req.meta.CopyFrom(ListRequestMetadata()) 7831 if self.parent.page_limit > 0: 7832 req.meta.limit = self.parent.page_limit 7833 if self.parent.snapshot_datetime is not None: 7834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7835 7836 req.filter = plumbing.quote_filter_args(filter, *args) 7837 7838 def generator(svc, req): 7839 tries = 0 7840 while True: 7841 t = None if deadline is None else deadline - time.time() 7842 try: 7843 plumbing_response = svc.stub.List( 7844 req, 7845 metadata=svc.parent.get_metadata( 7846 'WorkflowRolesHistory.List', req), 7847 timeout=t) 7848 except Exception as e: 7849 if self.parent.shouldRetry(tries, e, deadline): 7850 tries += 1 7851 time.sleep( 7852 self.parent.exponentialBackoff(tries, deadline)) 7853 continue 7854 raise plumbing.convert_error_to_porcelain(e) from e 7855 tries = 0 7856 for plumbing_item in plumbing_response.history: 7857 yield plumbing.convert_workflow_role_history_to_porcelain( 7858 plumbing_item) 7859 if plumbing_response.meta.next_cursor == '': 7860 break 7861 req.meta.cursor = plumbing_response.meta.next_cursor 7862 7863 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
7866class Workflows: 7867 ''' 7868 Workflows are the collection of rules that define the resources to which access can be requested, 7869 the users that can request that access, and the mechanism for approving those requests which can either 7870 be automatic approval or a set of users authorized to approve the requests. 7871 See `strongdm.models.Workflow`. 7872 ''' 7873 def __init__(self, channel, client): 7874 self.parent = client 7875 self.stub = WorkflowsStub(channel) 7876 7877 def create(self, workflow, timeout=None): 7878 ''' 7879 Create creates a new workflow and requires a name for the workflow. 7880 ''' 7881 deadline = None if timeout is None else time.time() + timeout 7882 req = WorkflowCreateRequest() 7883 7884 if workflow is not None: 7885 req.workflow.CopyFrom( 7886 plumbing.convert_workflow_to_plumbing(workflow)) 7887 tries = 0 7888 plumbing_response = None 7889 while True: 7890 t = None if deadline is None else deadline - time.time() 7891 try: 7892 plumbing_response = self.stub.Create( 7893 req, 7894 metadata=self.parent.get_metadata('Workflows.Create', req), 7895 timeout=t) 7896 except Exception as e: 7897 if self.parent.shouldRetry(tries, e, deadline): 7898 tries += 1 7899 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7900 continue 7901 raise plumbing.convert_error_to_porcelain(e) from e 7902 break 7903 7904 resp = models.WorkflowCreateResponse() 7905 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7906 plumbing_response.rate_limit) 7907 resp.workflow = plumbing.convert_workflow_to_porcelain( 7908 plumbing_response.workflow) 7909 return resp 7910 7911 def get(self, id, timeout=None): 7912 ''' 7913 Get reads one workflow by ID. 7914 ''' 7915 deadline = None if timeout is None else time.time() + timeout 7916 req = WorkflowGetRequest() 7917 if self.parent.snapshot_datetime is not None: 7918 req.meta.CopyFrom(GetRequestMetadata()) 7919 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7920 7921 req.id = (id) 7922 tries = 0 7923 plumbing_response = None 7924 while True: 7925 t = None if deadline is None else deadline - time.time() 7926 try: 7927 plumbing_response = self.stub.Get( 7928 req, 7929 metadata=self.parent.get_metadata('Workflows.Get', req), 7930 timeout=t) 7931 except Exception as e: 7932 if self.parent.shouldRetry(tries, e, deadline): 7933 tries += 1 7934 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7935 continue 7936 raise plumbing.convert_error_to_porcelain(e) from e 7937 break 7938 7939 resp = models.WorkflowGetResponse() 7940 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7941 plumbing_response.meta) 7942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7943 plumbing_response.rate_limit) 7944 resp.workflow = plumbing.convert_workflow_to_porcelain( 7945 plumbing_response.workflow) 7946 return resp 7947 7948 def delete(self, id, timeout=None): 7949 ''' 7950 Delete deletes an existing workflow. 7951 ''' 7952 deadline = None if timeout is None else time.time() + timeout 7953 req = WorkflowDeleteRequest() 7954 7955 req.id = (id) 7956 tries = 0 7957 plumbing_response = None 7958 while True: 7959 t = None if deadline is None else deadline - time.time() 7960 try: 7961 plumbing_response = self.stub.Delete( 7962 req, 7963 metadata=self.parent.get_metadata('Workflows.Delete', req), 7964 timeout=t) 7965 except Exception as e: 7966 if self.parent.shouldRetry(tries, e, deadline): 7967 tries += 1 7968 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7969 continue 7970 raise plumbing.convert_error_to_porcelain(e) from e 7971 break 7972 7973 resp = models.WorkflowDeleteResponse() 7974 resp.id = (plumbing_response.id) 7975 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7976 plumbing_response.rate_limit) 7977 return resp 7978 7979 def update(self, workflow, timeout=None): 7980 ''' 7981 Update updates an existing workflow. 7982 ''' 7983 deadline = None if timeout is None else time.time() + timeout 7984 req = WorkflowUpdateRequest() 7985 7986 if workflow is not None: 7987 req.workflow.CopyFrom( 7988 plumbing.convert_workflow_to_plumbing(workflow)) 7989 tries = 0 7990 plumbing_response = None 7991 while True: 7992 t = None if deadline is None else deadline - time.time() 7993 try: 7994 plumbing_response = self.stub.Update( 7995 req, 7996 metadata=self.parent.get_metadata('Workflows.Update', req), 7997 timeout=t) 7998 except Exception as e: 7999 if self.parent.shouldRetry(tries, e, deadline): 8000 tries += 1 8001 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8002 continue 8003 raise plumbing.convert_error_to_porcelain(e) from e 8004 break 8005 8006 resp = models.WorkflowUpdateResponse() 8007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8008 plumbing_response.rate_limit) 8009 resp.workflow = plumbing.convert_workflow_to_porcelain( 8010 plumbing_response.workflow) 8011 return resp 8012 8013 def list(self, filter, *args, timeout=None): 8014 ''' 8015 Lists existing workflows. 8016 ''' 8017 deadline = None if timeout is None else time.time() + timeout 8018 req = WorkflowListRequest() 8019 req.meta.CopyFrom(ListRequestMetadata()) 8020 if self.parent.page_limit > 0: 8021 req.meta.limit = self.parent.page_limit 8022 if self.parent.snapshot_datetime is not None: 8023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8024 8025 req.filter = plumbing.quote_filter_args(filter, *args) 8026 8027 def generator(svc, req): 8028 tries = 0 8029 while True: 8030 t = None if deadline is None else deadline - time.time() 8031 try: 8032 plumbing_response = svc.stub.List( 8033 req, 8034 metadata=svc.parent.get_metadata( 8035 'Workflows.List', req), 8036 timeout=t) 8037 except Exception as e: 8038 if self.parent.shouldRetry(tries, e, deadline): 8039 tries += 1 8040 time.sleep( 8041 self.parent.exponentialBackoff(tries, deadline)) 8042 continue 8043 raise plumbing.convert_error_to_porcelain(e) from e 8044 tries = 0 8045 for plumbing_item in plumbing_response.workflows: 8046 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8047 if plumbing_response.meta.next_cursor == '': 8048 break 8049 req.meta.cursor = plumbing_response.meta.next_cursor 8050 8051 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)
7877 def create(self, workflow, timeout=None): 7878 ''' 7879 Create creates a new workflow and requires a name for the workflow. 7880 ''' 7881 deadline = None if timeout is None else time.time() + timeout 7882 req = WorkflowCreateRequest() 7883 7884 if workflow is not None: 7885 req.workflow.CopyFrom( 7886 plumbing.convert_workflow_to_plumbing(workflow)) 7887 tries = 0 7888 plumbing_response = None 7889 while True: 7890 t = None if deadline is None else deadline - time.time() 7891 try: 7892 plumbing_response = self.stub.Create( 7893 req, 7894 metadata=self.parent.get_metadata('Workflows.Create', req), 7895 timeout=t) 7896 except Exception as e: 7897 if self.parent.shouldRetry(tries, e, deadline): 7898 tries += 1 7899 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7900 continue 7901 raise plumbing.convert_error_to_porcelain(e) from e 7902 break 7903 7904 resp = models.WorkflowCreateResponse() 7905 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7906 plumbing_response.rate_limit) 7907 resp.workflow = plumbing.convert_workflow_to_porcelain( 7908 plumbing_response.workflow) 7909 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
7911 def get(self, id, timeout=None): 7912 ''' 7913 Get reads one workflow by ID. 7914 ''' 7915 deadline = None if timeout is None else time.time() + timeout 7916 req = WorkflowGetRequest() 7917 if self.parent.snapshot_datetime is not None: 7918 req.meta.CopyFrom(GetRequestMetadata()) 7919 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7920 7921 req.id = (id) 7922 tries = 0 7923 plumbing_response = None 7924 while True: 7925 t = None if deadline is None else deadline - time.time() 7926 try: 7927 plumbing_response = self.stub.Get( 7928 req, 7929 metadata=self.parent.get_metadata('Workflows.Get', req), 7930 timeout=t) 7931 except Exception as e: 7932 if self.parent.shouldRetry(tries, e, deadline): 7933 tries += 1 7934 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7935 continue 7936 raise plumbing.convert_error_to_porcelain(e) from e 7937 break 7938 7939 resp = models.WorkflowGetResponse() 7940 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7941 plumbing_response.meta) 7942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7943 plumbing_response.rate_limit) 7944 resp.workflow = plumbing.convert_workflow_to_porcelain( 7945 plumbing_response.workflow) 7946 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
7948 def delete(self, id, timeout=None): 7949 ''' 7950 Delete deletes an existing workflow. 7951 ''' 7952 deadline = None if timeout is None else time.time() + timeout 7953 req = WorkflowDeleteRequest() 7954 7955 req.id = (id) 7956 tries = 0 7957 plumbing_response = None 7958 while True: 7959 t = None if deadline is None else deadline - time.time() 7960 try: 7961 plumbing_response = self.stub.Delete( 7962 req, 7963 metadata=self.parent.get_metadata('Workflows.Delete', req), 7964 timeout=t) 7965 except Exception as e: 7966 if self.parent.shouldRetry(tries, e, deadline): 7967 tries += 1 7968 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7969 continue 7970 raise plumbing.convert_error_to_porcelain(e) from e 7971 break 7972 7973 resp = models.WorkflowDeleteResponse() 7974 resp.id = (plumbing_response.id) 7975 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7976 plumbing_response.rate_limit) 7977 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
7979 def update(self, workflow, timeout=None): 7980 ''' 7981 Update updates an existing workflow. 7982 ''' 7983 deadline = None if timeout is None else time.time() + timeout 7984 req = WorkflowUpdateRequest() 7985 7986 if workflow is not None: 7987 req.workflow.CopyFrom( 7988 plumbing.convert_workflow_to_plumbing(workflow)) 7989 tries = 0 7990 plumbing_response = None 7991 while True: 7992 t = None if deadline is None else deadline - time.time() 7993 try: 7994 plumbing_response = self.stub.Update( 7995 req, 7996 metadata=self.parent.get_metadata('Workflows.Update', req), 7997 timeout=t) 7998 except Exception as e: 7999 if self.parent.shouldRetry(tries, e, deadline): 8000 tries += 1 8001 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8002 continue 8003 raise plumbing.convert_error_to_porcelain(e) from e 8004 break 8005 8006 resp = models.WorkflowUpdateResponse() 8007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8008 plumbing_response.rate_limit) 8009 resp.workflow = plumbing.convert_workflow_to_porcelain( 8010 plumbing_response.workflow) 8011 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8013 def list(self, filter, *args, timeout=None): 8014 ''' 8015 Lists existing workflows. 8016 ''' 8017 deadline = None if timeout is None else time.time() + timeout 8018 req = WorkflowListRequest() 8019 req.meta.CopyFrom(ListRequestMetadata()) 8020 if self.parent.page_limit > 0: 8021 req.meta.limit = self.parent.page_limit 8022 if self.parent.snapshot_datetime is not None: 8023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8024 8025 req.filter = plumbing.quote_filter_args(filter, *args) 8026 8027 def generator(svc, req): 8028 tries = 0 8029 while True: 8030 t = None if deadline is None else deadline - time.time() 8031 try: 8032 plumbing_response = svc.stub.List( 8033 req, 8034 metadata=svc.parent.get_metadata( 8035 'Workflows.List', req), 8036 timeout=t) 8037 except Exception as e: 8038 if self.parent.shouldRetry(tries, e, deadline): 8039 tries += 1 8040 time.sleep( 8041 self.parent.exponentialBackoff(tries, deadline)) 8042 continue 8043 raise plumbing.convert_error_to_porcelain(e) from e 8044 tries = 0 8045 for plumbing_item in plumbing_response.workflows: 8046 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8047 if plumbing_response.meta.next_cursor == '': 8048 break 8049 req.meta.cursor = plumbing_response.meta.next_cursor 8050 8051 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8054class SnapshotWorkflows: 8055 ''' 8056 SnapshotWorkflows exposes the read only methods of the Workflows 8057 service for historical queries. 8058 ''' 8059 def __init__(self, workflows): 8060 self.workflows = workflows 8061 8062 def get(self, id, timeout=None): 8063 ''' 8064 Get reads one workflow by ID. 8065 ''' 8066 return self.workflows.get(id, timeout=timeout) 8067 8068 def list(self, filter, *args, timeout=None): 8069 ''' 8070 Lists existing workflows. 8071 ''' 8072 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8075class WorkflowsHistory: 8076 ''' 8077 WorkflowsHistory provides records of all changes to the state of a Workflow. 8078 See `strongdm.models.WorkflowHistory`. 8079 ''' 8080 def __init__(self, channel, client): 8081 self.parent = client 8082 self.stub = WorkflowsHistoryStub(channel) 8083 8084 def list(self, filter, *args, timeout=None): 8085 ''' 8086 List gets a list of WorkflowHistory records matching a given set of criteria. 8087 ''' 8088 deadline = None if timeout is None else time.time() + timeout 8089 req = WorkflowHistoryListRequest() 8090 req.meta.CopyFrom(ListRequestMetadata()) 8091 if self.parent.page_limit > 0: 8092 req.meta.limit = self.parent.page_limit 8093 if self.parent.snapshot_datetime is not None: 8094 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8095 8096 req.filter = plumbing.quote_filter_args(filter, *args) 8097 8098 def generator(svc, req): 8099 tries = 0 8100 while True: 8101 t = None if deadline is None else deadline - time.time() 8102 try: 8103 plumbing_response = svc.stub.List( 8104 req, 8105 metadata=svc.parent.get_metadata( 8106 'WorkflowsHistory.List', req), 8107 timeout=t) 8108 except Exception as e: 8109 if self.parent.shouldRetry(tries, e, deadline): 8110 tries += 1 8111 time.sleep( 8112 self.parent.exponentialBackoff(tries, deadline)) 8113 continue 8114 raise plumbing.convert_error_to_porcelain(e) from e 8115 tries = 0 8116 for plumbing_item in plumbing_response.history: 8117 yield plumbing.convert_workflow_history_to_porcelain( 8118 plumbing_item) 8119 if plumbing_response.meta.next_cursor == '': 8120 break 8121 req.meta.cursor = plumbing_response.meta.next_cursor 8122 8123 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)
8084 def list(self, filter, *args, timeout=None): 8085 ''' 8086 List gets a list of WorkflowHistory records matching a given set of criteria. 8087 ''' 8088 deadline = None if timeout is None else time.time() + timeout 8089 req = WorkflowHistoryListRequest() 8090 req.meta.CopyFrom(ListRequestMetadata()) 8091 if self.parent.page_limit > 0: 8092 req.meta.limit = self.parent.page_limit 8093 if self.parent.snapshot_datetime is not None: 8094 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8095 8096 req.filter = plumbing.quote_filter_args(filter, *args) 8097 8098 def generator(svc, req): 8099 tries = 0 8100 while True: 8101 t = None if deadline is None else deadline - time.time() 8102 try: 8103 plumbing_response = svc.stub.List( 8104 req, 8105 metadata=svc.parent.get_metadata( 8106 'WorkflowsHistory.List', req), 8107 timeout=t) 8108 except Exception as e: 8109 if self.parent.shouldRetry(tries, e, deadline): 8110 tries += 1 8111 time.sleep( 8112 self.parent.exponentialBackoff(tries, deadline)) 8113 continue 8114 raise plumbing.convert_error_to_porcelain(e) from e 8115 tries = 0 8116 for plumbing_item in plumbing_response.history: 8117 yield plumbing.convert_workflow_history_to_porcelain( 8118 plumbing_item) 8119 if plumbing_response.meta.next_cursor == '': 8120 break 8121 req.meta.cursor = plumbing_response.meta.next_cursor 8122 8123 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.