strongdm.svc
1# Copyright 2020 StrongDM Inc 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# 15 16# Code generated by protogen. DO NOT EDIT. 17 18import grpc 19from . import plumbing 20from . import models 21from .options_pb2 import * 22from .options_pb2_grpc import * 23from .spec_pb2 import * 24from .spec_pb2_grpc import * 25from .tags_pb2 import * 26from .tags_pb2_grpc import * 27from .access_requests_pb2 import * 28from .access_requests_pb2_grpc import * 29from .access_request_events_history_pb2 import * 30from .access_request_events_history_pb2_grpc import * 31from .access_requests_history_pb2 import * 32from .access_requests_history_pb2_grpc import * 33from .drivers_pb2 import * 34from .drivers_pb2_grpc import * 35from .account_attachments_pb2 import * 36from .account_attachments_pb2_grpc import * 37from .account_attachments_history_pb2 import * 38from .account_attachments_history_pb2_grpc import * 39from .account_grants_pb2 import * 40from .account_grants_pb2_grpc import * 41from .account_grants_history_pb2 import * 42from .account_grants_history_pb2_grpc import * 43from .account_permissions_pb2 import * 44from .account_permissions_pb2_grpc import * 45from .account_resources_pb2 import * 46from .account_resources_pb2_grpc import * 47from .account_resources_history_pb2 import * 48from .account_resources_history_pb2_grpc import * 49from .accounts_pb2 import * 50from .accounts_pb2_grpc import * 51from .accounts_history_pb2 import * 52from .accounts_history_pb2_grpc import * 53from .activities_pb2 import * 54from .activities_pb2_grpc import * 55from .approval_workflow_approvers_pb2 import * 56from .approval_workflow_approvers_pb2_grpc import * 57from .approval_workflow_approvers_history_pb2 import * 58from .approval_workflow_approvers_history_pb2_grpc import * 59from .approval_workflow_steps_pb2 import * 60from .approval_workflow_steps_pb2_grpc import * 61from .approval_workflow_steps_history_pb2 import * 62from .approval_workflow_steps_history_pb2_grpc import * 63from .approval_workflows_pb2 import * 64from .approval_workflows_pb2_grpc import * 65from .approval_workflows_history_pb2 import * 66from .approval_workflows_history_pb2_grpc import * 67from .control_panel_pb2 import * 68from .control_panel_pb2_grpc import * 69from .roles_pb2 import * 70from .roles_pb2_grpc import * 71from .health_checks_pb2 import * 72from .health_checks_pb2_grpc import * 73from .identity_aliases_pb2 import * 74from .identity_aliases_pb2_grpc import * 75from .identity_aliases_history_pb2 import * 76from .identity_aliases_history_pb2_grpc import * 77from .identity_sets_pb2 import * 78from .identity_sets_pb2_grpc import * 79from .identity_sets_history_pb2 import * 80from .identity_sets_history_pb2_grpc import * 81from .managed_secrets_pb2 import * 82from .managed_secrets_pb2_grpc import * 83from .nodes_pb2 import * 84from .nodes_pb2_grpc import * 85from .nodes_history_pb2 import * 86from .nodes_history_pb2_grpc import * 87from .organization_history_pb2 import * 88from .organization_history_pb2_grpc import * 89from .peering_group_nodes_pb2 import * 90from .peering_group_nodes_pb2_grpc import * 91from .peering_group_peers_pb2 import * 92from .peering_group_peers_pb2_grpc import * 93from .peering_group_resources_pb2 import * 94from .peering_group_resources_pb2_grpc import * 95from .peering_groups_pb2 import * 96from .peering_groups_pb2_grpc import * 97from .policies_pb2 import * 98from .policies_pb2_grpc import * 99from .policies_history_pb2 import * 100from .policies_history_pb2_grpc import * 101from .proxy_cluster_keys_pb2 import * 102from .proxy_cluster_keys_pb2_grpc import * 103from .queries_pb2 import * 104from .queries_pb2_grpc import * 105from .remote_identities_pb2 import * 106from .remote_identities_pb2_grpc import * 107from .remote_identities_history_pb2 import * 108from .remote_identities_history_pb2_grpc import * 109from .remote_identity_groups_pb2 import * 110from .remote_identity_groups_pb2_grpc import * 111from .remote_identity_groups_history_pb2 import * 112from .remote_identity_groups_history_pb2_grpc import * 113from .replays_pb2 import * 114from .replays_pb2_grpc import * 115from .resources_pb2 import * 116from .resources_pb2_grpc import * 117from .resources_history_pb2 import * 118from .resources_history_pb2_grpc import * 119from .role_resources_pb2 import * 120from .role_resources_pb2_grpc import * 121from .role_resources_history_pb2 import * 122from .role_resources_history_pb2_grpc import * 123from .roles_history_pb2 import * 124from .roles_history_pb2_grpc import * 125from .secret_engine_policy_pb2 import * 126from .secret_engine_policy_pb2_grpc import * 127from .secret_engine_types_pb2 import * 128from .secret_engine_types_pb2_grpc import * 129from .secret_store_types_pb2 import * 130from .secret_store_types_pb2_grpc import * 131from .secret_stores_pb2 import * 132from .secret_stores_pb2_grpc import * 133from .secret_engines_pb2 import * 134from .secret_engines_pb2_grpc import * 135from .secret_store_healths_pb2 import * 136from .secret_store_healths_pb2_grpc import * 137from .secret_stores_history_pb2 import * 138from .secret_stores_history_pb2_grpc import * 139from .workflow_approvers_pb2 import * 140from .workflow_approvers_pb2_grpc import * 141from .workflow_approvers_history_pb2 import * 142from .workflow_approvers_history_pb2_grpc import * 143from .workflow_roles_pb2 import * 144from .workflow_roles_pb2_grpc import * 145from .workflow_roles_history_pb2 import * 146from .workflow_roles_history_pb2_grpc import * 147from .workflows_pb2 import * 148from .workflows_pb2_grpc import * 149from .workflows_history_pb2 import * 150from .workflows_history_pb2_grpc import * 151import warnings 152import functools 153import time 154 155 156def deprecated(func): 157 """This is a decorator which can be used to mark functions 158 as deprecated. It will result in a warning being emitted 159 when the function is used.""" 160 @functools.wraps(func) 161 def new_func(*args, **kwargs): 162 warnings.warn("Call to deprecated function {}.".format(func.__name__), 163 category=DeprecationWarning, 164 stacklevel=2) 165 return func(*args, **kwargs) 166 167 return new_func 168 169 170class AccessRequests: 171 ''' 172 AccessRequests are requests for access to a resource that may match a Workflow. 173 See `strongdm.models.AccessRequest`. 174 ''' 175 def __init__(self, channel, client): 176 self.parent = client 177 self.stub = AccessRequestsStub(channel) 178 179 def list(self, filter, *args, timeout=None): 180 ''' 181 Lists existing access requests. 182 ''' 183 deadline = None if timeout is None else time.time() + timeout 184 req = AccessRequestListRequest() 185 req.meta.CopyFrom(ListRequestMetadata()) 186 if self.parent.page_limit > 0: 187 req.meta.limit = self.parent.page_limit 188 if self.parent.snapshot_datetime is not None: 189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 190 191 req.filter = plumbing.quote_filter_args(filter, *args) 192 193 def generator(svc, req): 194 tries = 0 195 while True: 196 t = None if deadline is None else deadline - time.time() 197 try: 198 plumbing_response = svc.stub.List( 199 req, 200 metadata=svc.parent.get_metadata( 201 'AccessRequests.List', req), 202 timeout=t) 203 except Exception as e: 204 if self.parent.shouldRetry(tries, e, deadline): 205 tries += 1 206 time.sleep( 207 self.parent.exponentialBackoff(tries, deadline)) 208 continue 209 raise plumbing.convert_error_to_porcelain(e) from e 210 tries = 0 211 for plumbing_item in plumbing_response.access_requests: 212 yield plumbing.convert_access_request_to_porcelain( 213 plumbing_item) 214 if plumbing_response.meta.next_cursor == '': 215 break 216 req.meta.cursor = plumbing_response.meta.next_cursor 217 218 return generator(self, req) 219 220 221class SnapshotAccessRequests: 222 ''' 223 SnapshotAccessRequests exposes the read only methods of the AccessRequests 224 service for historical queries. 225 ''' 226 def __init__(self, access_requests): 227 self.access_requests = access_requests 228 229 def list(self, filter, *args, timeout=None): 230 ''' 231 Lists existing access requests. 232 ''' 233 return self.access_requests.list(filter, *args, timeout=timeout) 234 235 236class AccessRequestEventsHistory: 237 ''' 238 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 239 See `strongdm.models.AccessRequestEventHistory`. 240 ''' 241 def __init__(self, channel, client): 242 self.parent = client 243 self.stub = AccessRequestEventsHistoryStub(channel) 244 245 def list(self, filter, *args, timeout=None): 246 ''' 247 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 248 ''' 249 deadline = None if timeout is None else time.time() + timeout 250 req = AccessRequestEventHistoryListRequest() 251 req.meta.CopyFrom(ListRequestMetadata()) 252 if self.parent.page_limit > 0: 253 req.meta.limit = self.parent.page_limit 254 if self.parent.snapshot_datetime is not None: 255 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 256 257 req.filter = plumbing.quote_filter_args(filter, *args) 258 259 def generator(svc, req): 260 tries = 0 261 while True: 262 t = None if deadline is None else deadline - time.time() 263 try: 264 plumbing_response = svc.stub.List( 265 req, 266 metadata=svc.parent.get_metadata( 267 'AccessRequestEventsHistory.List', req), 268 timeout=t) 269 except Exception as e: 270 if self.parent.shouldRetry(tries, e, deadline): 271 tries += 1 272 time.sleep( 273 self.parent.exponentialBackoff(tries, deadline)) 274 continue 275 raise plumbing.convert_error_to_porcelain(e) from e 276 tries = 0 277 for plumbing_item in plumbing_response.history: 278 yield plumbing.convert_access_request_event_history_to_porcelain( 279 plumbing_item) 280 if plumbing_response.meta.next_cursor == '': 281 break 282 req.meta.cursor = plumbing_response.meta.next_cursor 283 284 return generator(self, req) 285 286 287class AccessRequestsHistory: 288 ''' 289 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 290 See `strongdm.models.AccessRequestHistory`. 291 ''' 292 def __init__(self, channel, client): 293 self.parent = client 294 self.stub = AccessRequestsHistoryStub(channel) 295 296 def list(self, filter, *args, timeout=None): 297 ''' 298 List gets a list of AccessRequestHistory records matching a given set of criteria. 299 ''' 300 deadline = None if timeout is None else time.time() + timeout 301 req = AccessRequestHistoryListRequest() 302 req.meta.CopyFrom(ListRequestMetadata()) 303 if self.parent.page_limit > 0: 304 req.meta.limit = self.parent.page_limit 305 if self.parent.snapshot_datetime is not None: 306 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 307 308 req.filter = plumbing.quote_filter_args(filter, *args) 309 310 def generator(svc, req): 311 tries = 0 312 while True: 313 t = None if deadline is None else deadline - time.time() 314 try: 315 plumbing_response = svc.stub.List( 316 req, 317 metadata=svc.parent.get_metadata( 318 'AccessRequestsHistory.List', req), 319 timeout=t) 320 except Exception as e: 321 if self.parent.shouldRetry(tries, e, deadline): 322 tries += 1 323 time.sleep( 324 self.parent.exponentialBackoff(tries, deadline)) 325 continue 326 raise plumbing.convert_error_to_porcelain(e) from e 327 tries = 0 328 for plumbing_item in plumbing_response.history: 329 yield plumbing.convert_access_request_history_to_porcelain( 330 plumbing_item) 331 if plumbing_response.meta.next_cursor == '': 332 break 333 req.meta.cursor = plumbing_response.meta.next_cursor 334 335 return generator(self, req) 336 337 338class AccountAttachments: 339 ''' 340 AccountAttachments assign an account to a role. 341 See `strongdm.models.AccountAttachment`. 342 ''' 343 def __init__(self, channel, client): 344 self.parent = client 345 self.stub = AccountAttachmentsStub(channel) 346 347 def create(self, account_attachment, timeout=None): 348 ''' 349 Create registers a new AccountAttachment. 350 ''' 351 deadline = None if timeout is None else time.time() + timeout 352 req = AccountAttachmentCreateRequest() 353 354 if account_attachment is not None: 355 req.account_attachment.CopyFrom( 356 plumbing.convert_account_attachment_to_plumbing( 357 account_attachment)) 358 tries = 0 359 plumbing_response = None 360 while True: 361 t = None if deadline is None else deadline - time.time() 362 try: 363 plumbing_response = self.stub.Create( 364 req, 365 metadata=self.parent.get_metadata( 366 'AccountAttachments.Create', req), 367 timeout=t) 368 except Exception as e: 369 if self.parent.shouldRetry(tries, e, deadline): 370 tries += 1 371 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 372 continue 373 raise plumbing.convert_error_to_porcelain(e) from e 374 break 375 376 resp = models.AccountAttachmentCreateResponse() 377 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 378 plumbing_response.account_attachment) 379 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 380 plumbing_response.meta) 381 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 382 plumbing_response.rate_limit) 383 return resp 384 385 def get(self, id, timeout=None): 386 ''' 387 Get reads one AccountAttachment by ID. 388 ''' 389 deadline = None if timeout is None else time.time() + timeout 390 req = AccountAttachmentGetRequest() 391 if self.parent.snapshot_datetime is not None: 392 req.meta.CopyFrom(GetRequestMetadata()) 393 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 394 395 req.id = (id) 396 tries = 0 397 plumbing_response = None 398 while True: 399 t = None if deadline is None else deadline - time.time() 400 try: 401 plumbing_response = self.stub.Get( 402 req, 403 metadata=self.parent.get_metadata('AccountAttachments.Get', 404 req), 405 timeout=t) 406 except Exception as e: 407 if self.parent.shouldRetry(tries, e, deadline): 408 tries += 1 409 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 410 continue 411 raise plumbing.convert_error_to_porcelain(e) from e 412 break 413 414 resp = models.AccountAttachmentGetResponse() 415 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 416 plumbing_response.account_attachment) 417 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 418 plumbing_response.meta) 419 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 420 plumbing_response.rate_limit) 421 return resp 422 423 def delete(self, id, timeout=None): 424 ''' 425 Delete removes a AccountAttachment by ID. 426 ''' 427 deadline = None if timeout is None else time.time() + timeout 428 req = AccountAttachmentDeleteRequest() 429 430 req.id = (id) 431 tries = 0 432 plumbing_response = None 433 while True: 434 t = None if deadline is None else deadline - time.time() 435 try: 436 plumbing_response = self.stub.Delete( 437 req, 438 metadata=self.parent.get_metadata( 439 'AccountAttachments.Delete', req), 440 timeout=t) 441 except Exception as e: 442 if self.parent.shouldRetry(tries, e, deadline): 443 tries += 1 444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 445 continue 446 raise plumbing.convert_error_to_porcelain(e) from e 447 break 448 449 resp = models.AccountAttachmentDeleteResponse() 450 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 451 plumbing_response.meta) 452 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 453 plumbing_response.rate_limit) 454 return resp 455 456 def list(self, filter, *args, timeout=None): 457 ''' 458 List gets a list of AccountAttachments matching a given set of criteria. 459 ''' 460 deadline = None if timeout is None else time.time() + timeout 461 req = AccountAttachmentListRequest() 462 req.meta.CopyFrom(ListRequestMetadata()) 463 if self.parent.page_limit > 0: 464 req.meta.limit = self.parent.page_limit 465 if self.parent.snapshot_datetime is not None: 466 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 467 468 req.filter = plumbing.quote_filter_args(filter, *args) 469 470 def generator(svc, req): 471 tries = 0 472 while True: 473 t = None if deadline is None else deadline - time.time() 474 try: 475 plumbing_response = svc.stub.List( 476 req, 477 metadata=svc.parent.get_metadata( 478 'AccountAttachments.List', req), 479 timeout=t) 480 except Exception as e: 481 if self.parent.shouldRetry(tries, e, deadline): 482 tries += 1 483 time.sleep( 484 self.parent.exponentialBackoff(tries, deadline)) 485 continue 486 raise plumbing.convert_error_to_porcelain(e) from e 487 tries = 0 488 for plumbing_item in plumbing_response.account_attachments: 489 yield plumbing.convert_account_attachment_to_porcelain( 490 plumbing_item) 491 if plumbing_response.meta.next_cursor == '': 492 break 493 req.meta.cursor = plumbing_response.meta.next_cursor 494 495 return generator(self, req) 496 497 498class SnapshotAccountAttachments: 499 ''' 500 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 501 service for historical queries. 502 ''' 503 def __init__(self, account_attachments): 504 self.account_attachments = account_attachments 505 506 def get(self, id, timeout=None): 507 ''' 508 Get reads one AccountAttachment by ID. 509 ''' 510 return self.account_attachments.get(id, timeout=timeout) 511 512 def list(self, filter, *args, timeout=None): 513 ''' 514 List gets a list of AccountAttachments matching a given set of criteria. 515 ''' 516 return self.account_attachments.list(filter, *args, timeout=timeout) 517 518 519class AccountAttachmentsHistory: 520 ''' 521 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 522 See `strongdm.models.AccountAttachmentHistory`. 523 ''' 524 def __init__(self, channel, client): 525 self.parent = client 526 self.stub = AccountAttachmentsHistoryStub(channel) 527 528 def list(self, filter, *args, timeout=None): 529 ''' 530 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 531 ''' 532 deadline = None if timeout is None else time.time() + timeout 533 req = AccountAttachmentHistoryListRequest() 534 req.meta.CopyFrom(ListRequestMetadata()) 535 if self.parent.page_limit > 0: 536 req.meta.limit = self.parent.page_limit 537 if self.parent.snapshot_datetime is not None: 538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 539 540 req.filter = plumbing.quote_filter_args(filter, *args) 541 542 def generator(svc, req): 543 tries = 0 544 while True: 545 t = None if deadline is None else deadline - time.time() 546 try: 547 plumbing_response = svc.stub.List( 548 req, 549 metadata=svc.parent.get_metadata( 550 'AccountAttachmentsHistory.List', req), 551 timeout=t) 552 except Exception as e: 553 if self.parent.shouldRetry(tries, e, deadline): 554 tries += 1 555 time.sleep( 556 self.parent.exponentialBackoff(tries, deadline)) 557 continue 558 raise plumbing.convert_error_to_porcelain(e) from e 559 tries = 0 560 for plumbing_item in plumbing_response.history: 561 yield plumbing.convert_account_attachment_history_to_porcelain( 562 plumbing_item) 563 if plumbing_response.meta.next_cursor == '': 564 break 565 req.meta.cursor = plumbing_response.meta.next_cursor 566 567 return generator(self, req) 568 569 570class AccountGrants: 571 ''' 572 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 573 See `strongdm.models.AccountGrant`. 574 ''' 575 def __init__(self, channel, client): 576 self.parent = client 577 self.stub = AccountGrantsStub(channel) 578 579 def create(self, account_grant, timeout=None): 580 ''' 581 Create registers a new AccountGrant. 582 ''' 583 deadline = None if timeout is None else time.time() + timeout 584 req = AccountGrantCreateRequest() 585 586 if account_grant is not None: 587 req.account_grant.CopyFrom( 588 plumbing.convert_account_grant_to_plumbing(account_grant)) 589 tries = 0 590 plumbing_response = None 591 while True: 592 t = None if deadline is None else deadline - time.time() 593 try: 594 plumbing_response = self.stub.Create( 595 req, 596 metadata=self.parent.get_metadata('AccountGrants.Create', 597 req), 598 timeout=t) 599 except Exception as e: 600 if self.parent.shouldRetry(tries, e, deadline): 601 tries += 1 602 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 603 continue 604 raise plumbing.convert_error_to_porcelain(e) from e 605 break 606 607 resp = models.AccountGrantCreateResponse() 608 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 609 plumbing_response.account_grant) 610 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 611 plumbing_response.meta) 612 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 613 plumbing_response.rate_limit) 614 return resp 615 616 def get(self, id, timeout=None): 617 ''' 618 Get reads one AccountGrant by ID. 619 ''' 620 deadline = None if timeout is None else time.time() + timeout 621 req = AccountGrantGetRequest() 622 if self.parent.snapshot_datetime is not None: 623 req.meta.CopyFrom(GetRequestMetadata()) 624 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 625 626 req.id = (id) 627 tries = 0 628 plumbing_response = None 629 while True: 630 t = None if deadline is None else deadline - time.time() 631 try: 632 plumbing_response = self.stub.Get( 633 req, 634 metadata=self.parent.get_metadata('AccountGrants.Get', 635 req), 636 timeout=t) 637 except Exception as e: 638 if self.parent.shouldRetry(tries, e, deadline): 639 tries += 1 640 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 641 continue 642 raise plumbing.convert_error_to_porcelain(e) from e 643 break 644 645 resp = models.AccountGrantGetResponse() 646 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 647 plumbing_response.account_grant) 648 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 649 plumbing_response.meta) 650 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 651 plumbing_response.rate_limit) 652 return resp 653 654 def delete(self, id, timeout=None): 655 ''' 656 Delete removes a AccountGrant by ID. 657 ''' 658 deadline = None if timeout is None else time.time() + timeout 659 req = AccountGrantDeleteRequest() 660 661 req.id = (id) 662 tries = 0 663 plumbing_response = None 664 while True: 665 t = None if deadline is None else deadline - time.time() 666 try: 667 plumbing_response = self.stub.Delete( 668 req, 669 metadata=self.parent.get_metadata('AccountGrants.Delete', 670 req), 671 timeout=t) 672 except Exception as e: 673 if self.parent.shouldRetry(tries, e, deadline): 674 tries += 1 675 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 676 continue 677 raise plumbing.convert_error_to_porcelain(e) from e 678 break 679 680 resp = models.AccountGrantDeleteResponse() 681 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 682 plumbing_response.meta) 683 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 684 plumbing_response.rate_limit) 685 return resp 686 687 def list(self, filter, *args, timeout=None): 688 ''' 689 List gets a list of AccountGrants matching a given set of criteria. 690 ''' 691 deadline = None if timeout is None else time.time() + timeout 692 req = AccountGrantListRequest() 693 req.meta.CopyFrom(ListRequestMetadata()) 694 if self.parent.page_limit > 0: 695 req.meta.limit = self.parent.page_limit 696 if self.parent.snapshot_datetime is not None: 697 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 698 699 req.filter = plumbing.quote_filter_args(filter, *args) 700 701 def generator(svc, req): 702 tries = 0 703 while True: 704 t = None if deadline is None else deadline - time.time() 705 try: 706 plumbing_response = svc.stub.List( 707 req, 708 metadata=svc.parent.get_metadata( 709 'AccountGrants.List', req), 710 timeout=t) 711 except Exception as e: 712 if self.parent.shouldRetry(tries, e, deadline): 713 tries += 1 714 time.sleep( 715 self.parent.exponentialBackoff(tries, deadline)) 716 continue 717 raise plumbing.convert_error_to_porcelain(e) from e 718 tries = 0 719 for plumbing_item in plumbing_response.account_grants: 720 yield plumbing.convert_account_grant_to_porcelain( 721 plumbing_item) 722 if plumbing_response.meta.next_cursor == '': 723 break 724 req.meta.cursor = plumbing_response.meta.next_cursor 725 726 return generator(self, req) 727 728 729class SnapshotAccountGrants: 730 ''' 731 SnapshotAccountGrants exposes the read only methods of the AccountGrants 732 service for historical queries. 733 ''' 734 def __init__(self, account_grants): 735 self.account_grants = account_grants 736 737 def get(self, id, timeout=None): 738 ''' 739 Get reads one AccountGrant by ID. 740 ''' 741 return self.account_grants.get(id, timeout=timeout) 742 743 def list(self, filter, *args, timeout=None): 744 ''' 745 List gets a list of AccountGrants matching a given set of criteria. 746 ''' 747 return self.account_grants.list(filter, *args, timeout=timeout) 748 749 750class AccountGrantsHistory: 751 ''' 752 AccountGrantsHistory records all changes to the state of an AccountGrant. 753 See `strongdm.models.AccountGrantHistory`. 754 ''' 755 def __init__(self, channel, client): 756 self.parent = client 757 self.stub = AccountGrantsHistoryStub(channel) 758 759 def list(self, filter, *args, timeout=None): 760 ''' 761 List gets a list of AccountGrantHistory records matching a given set of criteria. 762 ''' 763 deadline = None if timeout is None else time.time() + timeout 764 req = AccountGrantHistoryListRequest() 765 req.meta.CopyFrom(ListRequestMetadata()) 766 if self.parent.page_limit > 0: 767 req.meta.limit = self.parent.page_limit 768 if self.parent.snapshot_datetime is not None: 769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 770 771 req.filter = plumbing.quote_filter_args(filter, *args) 772 773 def generator(svc, req): 774 tries = 0 775 while True: 776 t = None if deadline is None else deadline - time.time() 777 try: 778 plumbing_response = svc.stub.List( 779 req, 780 metadata=svc.parent.get_metadata( 781 'AccountGrantsHistory.List', req), 782 timeout=t) 783 except Exception as e: 784 if self.parent.shouldRetry(tries, e, deadline): 785 tries += 1 786 time.sleep( 787 self.parent.exponentialBackoff(tries, deadline)) 788 continue 789 raise plumbing.convert_error_to_porcelain(e) from e 790 tries = 0 791 for plumbing_item in plumbing_response.history: 792 yield plumbing.convert_account_grant_history_to_porcelain( 793 plumbing_item) 794 if plumbing_response.meta.next_cursor == '': 795 break 796 req.meta.cursor = plumbing_response.meta.next_cursor 797 798 return generator(self, req) 799 800 801class AccountPermissions: 802 ''' 803 AccountPermissions records the granular permissions accounts have, allowing them to execute 804 relevant commands via StrongDM's APIs. 805 See `strongdm.models.AccountPermission`. 806 ''' 807 def __init__(self, channel, client): 808 self.parent = client 809 self.stub = AccountPermissionsStub(channel) 810 811 def list(self, filter, *args, timeout=None): 812 ''' 813 List gets a list of Permission records matching a given set of criteria. 814 ''' 815 deadline = None if timeout is None else time.time() + timeout 816 req = AccountPermissionListRequest() 817 req.meta.CopyFrom(ListRequestMetadata()) 818 if self.parent.page_limit > 0: 819 req.meta.limit = self.parent.page_limit 820 if self.parent.snapshot_datetime is not None: 821 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 822 823 req.filter = plumbing.quote_filter_args(filter, *args) 824 825 def generator(svc, req): 826 tries = 0 827 while True: 828 t = None if deadline is None else deadline - time.time() 829 try: 830 plumbing_response = svc.stub.List( 831 req, 832 metadata=svc.parent.get_metadata( 833 'AccountPermissions.List', req), 834 timeout=t) 835 except Exception as e: 836 if self.parent.shouldRetry(tries, e, deadline): 837 tries += 1 838 time.sleep( 839 self.parent.exponentialBackoff(tries, deadline)) 840 continue 841 raise plumbing.convert_error_to_porcelain(e) from e 842 tries = 0 843 for plumbing_item in plumbing_response.permissions: 844 yield plumbing.convert_account_permission_to_porcelain( 845 plumbing_item) 846 if plumbing_response.meta.next_cursor == '': 847 break 848 req.meta.cursor = plumbing_response.meta.next_cursor 849 850 return generator(self, req) 851 852 853class SnapshotAccountPermissions: 854 ''' 855 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 856 service for historical queries. 857 ''' 858 def __init__(self, account_permissions): 859 self.account_permissions = account_permissions 860 861 def list(self, filter, *args, timeout=None): 862 ''' 863 List gets a list of Permission records matching a given set of criteria. 864 ''' 865 return self.account_permissions.list(filter, *args, timeout=timeout) 866 867 868class AccountResources: 869 ''' 870 AccountResources enumerates the resources to which accounts have access. 871 The AccountResources service is read-only. 872 See `strongdm.models.AccountResource`. 873 ''' 874 def __init__(self, channel, client): 875 self.parent = client 876 self.stub = AccountResourcesStub(channel) 877 878 def list(self, filter, *args, timeout=None): 879 ''' 880 List gets a list of AccountResource records matching a given set of criteria. 881 ''' 882 deadline = None if timeout is None else time.time() + timeout 883 req = AccountResourceListRequest() 884 req.meta.CopyFrom(ListRequestMetadata()) 885 if self.parent.page_limit > 0: 886 req.meta.limit = self.parent.page_limit 887 if self.parent.snapshot_datetime is not None: 888 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 889 890 req.filter = plumbing.quote_filter_args(filter, *args) 891 892 def generator(svc, req): 893 tries = 0 894 while True: 895 t = None if deadline is None else deadline - time.time() 896 try: 897 plumbing_response = svc.stub.List( 898 req, 899 metadata=svc.parent.get_metadata( 900 'AccountResources.List', req), 901 timeout=t) 902 except Exception as e: 903 if self.parent.shouldRetry(tries, e, deadline): 904 tries += 1 905 time.sleep( 906 self.parent.exponentialBackoff(tries, deadline)) 907 continue 908 raise plumbing.convert_error_to_porcelain(e) from e 909 tries = 0 910 for plumbing_item in plumbing_response.account_resources: 911 yield plumbing.convert_account_resource_to_porcelain( 912 plumbing_item) 913 if plumbing_response.meta.next_cursor == '': 914 break 915 req.meta.cursor = plumbing_response.meta.next_cursor 916 917 return generator(self, req) 918 919 920class SnapshotAccountResources: 921 ''' 922 SnapshotAccountResources exposes the read only methods of the AccountResources 923 service for historical queries. 924 ''' 925 def __init__(self, account_resources): 926 self.account_resources = account_resources 927 928 def list(self, filter, *args, timeout=None): 929 ''' 930 List gets a list of AccountResource records matching a given set of criteria. 931 ''' 932 return self.account_resources.list(filter, *args, timeout=timeout) 933 934 935class AccountResourcesHistory: 936 ''' 937 AccountResourcesHistory records all changes to the state of a AccountResource. 938 See `strongdm.models.AccountResourceHistory`. 939 ''' 940 def __init__(self, channel, client): 941 self.parent = client 942 self.stub = AccountResourcesHistoryStub(channel) 943 944 def list(self, filter, *args, timeout=None): 945 ''' 946 List gets a list of AccountResourceHistory records matching a given set of criteria. 947 ''' 948 deadline = None if timeout is None else time.time() + timeout 949 req = AccountResourceHistoryListRequest() 950 req.meta.CopyFrom(ListRequestMetadata()) 951 if self.parent.page_limit > 0: 952 req.meta.limit = self.parent.page_limit 953 if self.parent.snapshot_datetime is not None: 954 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 955 956 req.filter = plumbing.quote_filter_args(filter, *args) 957 958 def generator(svc, req): 959 tries = 0 960 while True: 961 t = None if deadline is None else deadline - time.time() 962 try: 963 plumbing_response = svc.stub.List( 964 req, 965 metadata=svc.parent.get_metadata( 966 'AccountResourcesHistory.List', req), 967 timeout=t) 968 except Exception as e: 969 if self.parent.shouldRetry(tries, e, deadline): 970 tries += 1 971 time.sleep( 972 self.parent.exponentialBackoff(tries, deadline)) 973 continue 974 raise plumbing.convert_error_to_porcelain(e) from e 975 tries = 0 976 for plumbing_item in plumbing_response.history: 977 yield plumbing.convert_account_resource_history_to_porcelain( 978 plumbing_item) 979 if plumbing_response.meta.next_cursor == '': 980 break 981 req.meta.cursor = plumbing_response.meta.next_cursor 982 983 return generator(self, req) 984 985 986class Accounts: 987 ''' 988 Accounts are users that have access to strongDM. There are two types of accounts: 989 1. **Users:** humans who are authenticated through username and password or SSO. 990 2. **Service Accounts:** machines that are authenticated using a service token. 991 3. **Tokens** are access keys with permissions that can be used for authentication. 992 See: 993 `strongdm.models.Service` 994 `strongdm.models.Token` 995 `strongdm.models.User` 996 ''' 997 def __init__(self, channel, client): 998 self.parent = client 999 self.stub = AccountsStub(channel) 1000 1001 def create(self, account, timeout=None): 1002 ''' 1003 Create registers a new Account. 1004 ''' 1005 deadline = None if timeout is None else time.time() + timeout 1006 req = AccountCreateRequest() 1007 1008 if account is not None: 1009 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1010 tries = 0 1011 plumbing_response = None 1012 while True: 1013 t = None if deadline is None else deadline - time.time() 1014 try: 1015 plumbing_response = self.stub.Create( 1016 req, 1017 metadata=self.parent.get_metadata('Accounts.Create', req), 1018 timeout=t) 1019 except Exception as e: 1020 if self.parent.shouldRetry(tries, e, deadline): 1021 tries += 1 1022 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1023 continue 1024 raise plumbing.convert_error_to_porcelain(e) from e 1025 break 1026 1027 resp = models.AccountCreateResponse() 1028 resp.access_key = (plumbing_response.access_key) 1029 resp.account = plumbing.convert_account_to_porcelain( 1030 plumbing_response.account) 1031 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1032 plumbing_response.meta) 1033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1034 plumbing_response.rate_limit) 1035 resp.secret_key = (plumbing_response.secret_key) 1036 resp.token = (plumbing_response.token) 1037 return resp 1038 1039 def get(self, id, timeout=None): 1040 ''' 1041 Get reads one Account by ID. 1042 ''' 1043 deadline = None if timeout is None else time.time() + timeout 1044 req = AccountGetRequest() 1045 if self.parent.snapshot_datetime is not None: 1046 req.meta.CopyFrom(GetRequestMetadata()) 1047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1048 1049 req.id = (id) 1050 tries = 0 1051 plumbing_response = None 1052 while True: 1053 t = None if deadline is None else deadline - time.time() 1054 try: 1055 plumbing_response = self.stub.Get( 1056 req, 1057 metadata=self.parent.get_metadata('Accounts.Get', req), 1058 timeout=t) 1059 except Exception as e: 1060 if self.parent.shouldRetry(tries, e, deadline): 1061 tries += 1 1062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1063 continue 1064 raise plumbing.convert_error_to_porcelain(e) from e 1065 break 1066 1067 resp = models.AccountGetResponse() 1068 resp.account = plumbing.convert_account_to_porcelain( 1069 plumbing_response.account) 1070 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1071 plumbing_response.meta) 1072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1073 plumbing_response.rate_limit) 1074 return resp 1075 1076 def update(self, account, timeout=None): 1077 ''' 1078 Update replaces all the fields of an Account by ID. 1079 ''' 1080 deadline = None if timeout is None else time.time() + timeout 1081 req = AccountUpdateRequest() 1082 1083 if account is not None: 1084 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1085 tries = 0 1086 plumbing_response = None 1087 while True: 1088 t = None if deadline is None else deadline - time.time() 1089 try: 1090 plumbing_response = self.stub.Update( 1091 req, 1092 metadata=self.parent.get_metadata('Accounts.Update', req), 1093 timeout=t) 1094 except Exception as e: 1095 if self.parent.shouldRetry(tries, e, deadline): 1096 tries += 1 1097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1098 continue 1099 raise plumbing.convert_error_to_porcelain(e) from e 1100 break 1101 1102 resp = models.AccountUpdateResponse() 1103 resp.account = plumbing.convert_account_to_porcelain( 1104 plumbing_response.account) 1105 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1106 plumbing_response.meta) 1107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1108 plumbing_response.rate_limit) 1109 return resp 1110 1111 def delete(self, id, timeout=None): 1112 ''' 1113 Delete removes an Account by ID. 1114 ''' 1115 deadline = None if timeout is None else time.time() + timeout 1116 req = AccountDeleteRequest() 1117 1118 req.id = (id) 1119 tries = 0 1120 plumbing_response = None 1121 while True: 1122 t = None if deadline is None else deadline - time.time() 1123 try: 1124 plumbing_response = self.stub.Delete( 1125 req, 1126 metadata=self.parent.get_metadata('Accounts.Delete', req), 1127 timeout=t) 1128 except Exception as e: 1129 if self.parent.shouldRetry(tries, e, deadline): 1130 tries += 1 1131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1132 continue 1133 raise plumbing.convert_error_to_porcelain(e) from e 1134 break 1135 1136 resp = models.AccountDeleteResponse() 1137 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1138 plumbing_response.meta) 1139 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1140 plumbing_response.rate_limit) 1141 return resp 1142 1143 def list(self, filter, *args, timeout=None): 1144 ''' 1145 List gets a list of Accounts matching a given set of criteria. 1146 ''' 1147 deadline = None if timeout is None else time.time() + timeout 1148 req = AccountListRequest() 1149 req.meta.CopyFrom(ListRequestMetadata()) 1150 if self.parent.page_limit > 0: 1151 req.meta.limit = self.parent.page_limit 1152 if self.parent.snapshot_datetime is not None: 1153 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1154 1155 req.filter = plumbing.quote_filter_args(filter, *args) 1156 1157 def generator(svc, req): 1158 tries = 0 1159 while True: 1160 t = None if deadline is None else deadline - time.time() 1161 try: 1162 plumbing_response = svc.stub.List( 1163 req, 1164 metadata=svc.parent.get_metadata('Accounts.List', req), 1165 timeout=t) 1166 except Exception as e: 1167 if self.parent.shouldRetry(tries, e, deadline): 1168 tries += 1 1169 time.sleep( 1170 self.parent.exponentialBackoff(tries, deadline)) 1171 continue 1172 raise plumbing.convert_error_to_porcelain(e) from e 1173 tries = 0 1174 for plumbing_item in plumbing_response.accounts: 1175 yield plumbing.convert_account_to_porcelain(plumbing_item) 1176 if plumbing_response.meta.next_cursor == '': 1177 break 1178 req.meta.cursor = plumbing_response.meta.next_cursor 1179 1180 return generator(self, req) 1181 1182 1183class SnapshotAccounts: 1184 ''' 1185 SnapshotAccounts exposes the read only methods of the Accounts 1186 service for historical queries. 1187 ''' 1188 def __init__(self, accounts): 1189 self.accounts = accounts 1190 1191 def get(self, id, timeout=None): 1192 ''' 1193 Get reads one Account by ID. 1194 ''' 1195 return self.accounts.get(id, timeout=timeout) 1196 1197 def list(self, filter, *args, timeout=None): 1198 ''' 1199 List gets a list of Accounts matching a given set of criteria. 1200 ''' 1201 return self.accounts.list(filter, *args, timeout=timeout) 1202 1203 1204class AccountsHistory: 1205 ''' 1206 AccountsHistory records all changes to the state of an Account. 1207 See `strongdm.models.AccountHistory`. 1208 ''' 1209 def __init__(self, channel, client): 1210 self.parent = client 1211 self.stub = AccountsHistoryStub(channel) 1212 1213 def list(self, filter, *args, timeout=None): 1214 ''' 1215 List gets a list of AccountHistory records matching a given set of criteria. 1216 ''' 1217 deadline = None if timeout is None else time.time() + timeout 1218 req = AccountHistoryListRequest() 1219 req.meta.CopyFrom(ListRequestMetadata()) 1220 if self.parent.page_limit > 0: 1221 req.meta.limit = self.parent.page_limit 1222 if self.parent.snapshot_datetime is not None: 1223 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1224 1225 req.filter = plumbing.quote_filter_args(filter, *args) 1226 1227 def generator(svc, req): 1228 tries = 0 1229 while True: 1230 t = None if deadline is None else deadline - time.time() 1231 try: 1232 plumbing_response = svc.stub.List( 1233 req, 1234 metadata=svc.parent.get_metadata( 1235 'AccountsHistory.List', req), 1236 timeout=t) 1237 except Exception as e: 1238 if self.parent.shouldRetry(tries, e, deadline): 1239 tries += 1 1240 time.sleep( 1241 self.parent.exponentialBackoff(tries, deadline)) 1242 continue 1243 raise plumbing.convert_error_to_porcelain(e) from e 1244 tries = 0 1245 for plumbing_item in plumbing_response.history: 1246 yield plumbing.convert_account_history_to_porcelain( 1247 plumbing_item) 1248 if plumbing_response.meta.next_cursor == '': 1249 break 1250 req.meta.cursor = plumbing_response.meta.next_cursor 1251 1252 return generator(self, req) 1253 1254 1255class Activities: 1256 ''' 1257 An Activity is a record of an action taken against a strongDM deployment, e.g. 1258 a user creation, resource deletion, sso configuration change, etc. The Activities 1259 service is read-only. 1260 See `strongdm.models.Activity`. 1261 ''' 1262 def __init__(self, channel, client): 1263 self.parent = client 1264 self.stub = ActivitiesStub(channel) 1265 1266 def get(self, id, timeout=None): 1267 ''' 1268 Get reads one Activity by ID. 1269 ''' 1270 deadline = None if timeout is None else time.time() + timeout 1271 req = ActivityGetRequest() 1272 if self.parent.snapshot_datetime is not None: 1273 req.meta.CopyFrom(GetRequestMetadata()) 1274 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1275 1276 req.id = (id) 1277 tries = 0 1278 plumbing_response = None 1279 while True: 1280 t = None if deadline is None else deadline - time.time() 1281 try: 1282 plumbing_response = self.stub.Get( 1283 req, 1284 metadata=self.parent.get_metadata('Activities.Get', req), 1285 timeout=t) 1286 except Exception as e: 1287 if self.parent.shouldRetry(tries, e, deadline): 1288 tries += 1 1289 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1290 continue 1291 raise plumbing.convert_error_to_porcelain(e) from e 1292 break 1293 1294 resp = models.ActivityGetResponse() 1295 resp.activity = plumbing.convert_activity_to_porcelain( 1296 plumbing_response.activity) 1297 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1298 plumbing_response.meta) 1299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1300 plumbing_response.rate_limit) 1301 return resp 1302 1303 def list(self, filter, *args, timeout=None): 1304 ''' 1305 List gets a list of Activities matching a given set of criteria. 1306 The 'before' and 'after' filters can be used to control the time 1307 range of the output activities. If not provided, one week of back 1308 of activities will be returned. 1309 ''' 1310 deadline = None if timeout is None else time.time() + timeout 1311 req = ActivityListRequest() 1312 req.meta.CopyFrom(ListRequestMetadata()) 1313 if self.parent.page_limit > 0: 1314 req.meta.limit = self.parent.page_limit 1315 if self.parent.snapshot_datetime is not None: 1316 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1317 1318 req.filter = plumbing.quote_filter_args(filter, *args) 1319 1320 def generator(svc, req): 1321 tries = 0 1322 while True: 1323 t = None if deadline is None else deadline - time.time() 1324 try: 1325 plumbing_response = svc.stub.List( 1326 req, 1327 metadata=svc.parent.get_metadata( 1328 'Activities.List', req), 1329 timeout=t) 1330 except Exception as e: 1331 if self.parent.shouldRetry(tries, e, deadline): 1332 tries += 1 1333 time.sleep( 1334 self.parent.exponentialBackoff(tries, deadline)) 1335 continue 1336 raise plumbing.convert_error_to_porcelain(e) from e 1337 tries = 0 1338 for plumbing_item in plumbing_response.activities: 1339 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1340 if plumbing_response.meta.next_cursor == '': 1341 break 1342 req.meta.cursor = plumbing_response.meta.next_cursor 1343 1344 return generator(self, req) 1345 1346 1347class ApprovalWorkflowApprovers: 1348 ''' 1349 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1350 See `strongdm.models.ApprovalWorkflowApprover`. 1351 ''' 1352 def __init__(self, channel, client): 1353 self.parent = client 1354 self.stub = ApprovalWorkflowApproversStub(channel) 1355 1356 def create(self, approval_workflow_approver, timeout=None): 1357 ''' 1358 Deprecated: Create creates a new approval workflow approver. 1359 ''' 1360 deadline = None if timeout is None else time.time() + timeout 1361 req = ApprovalWorkflowApproverCreateRequest() 1362 1363 if approval_workflow_approver is not None: 1364 req.approval_workflow_approver.CopyFrom( 1365 plumbing.convert_approval_workflow_approver_to_plumbing( 1366 approval_workflow_approver)) 1367 tries = 0 1368 plumbing_response = None 1369 while True: 1370 t = None if deadline is None else deadline - time.time() 1371 try: 1372 plumbing_response = self.stub.Create( 1373 req, 1374 metadata=self.parent.get_metadata( 1375 'ApprovalWorkflowApprovers.Create', req), 1376 timeout=t) 1377 except Exception as e: 1378 if self.parent.shouldRetry(tries, e, deadline): 1379 tries += 1 1380 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1381 continue 1382 raise plumbing.convert_error_to_porcelain(e) from e 1383 break 1384 1385 resp = models.ApprovalWorkflowApproverCreateResponse() 1386 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1387 plumbing_response.approval_workflow_approver) 1388 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1389 plumbing_response.rate_limit) 1390 return resp 1391 1392 def get(self, id, timeout=None): 1393 ''' 1394 Deprecated: Get reads one approval workflow approver by ID. 1395 ''' 1396 deadline = None if timeout is None else time.time() + timeout 1397 req = ApprovalWorkflowApproverGetRequest() 1398 if self.parent.snapshot_datetime is not None: 1399 req.meta.CopyFrom(GetRequestMetadata()) 1400 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1401 1402 req.id = (id) 1403 tries = 0 1404 plumbing_response = None 1405 while True: 1406 t = None if deadline is None else deadline - time.time() 1407 try: 1408 plumbing_response = self.stub.Get( 1409 req, 1410 metadata=self.parent.get_metadata( 1411 'ApprovalWorkflowApprovers.Get', req), 1412 timeout=t) 1413 except Exception as e: 1414 if self.parent.shouldRetry(tries, e, deadline): 1415 tries += 1 1416 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1417 continue 1418 raise plumbing.convert_error_to_porcelain(e) from e 1419 break 1420 1421 resp = models.ApprovalWorkflowApproverGetResponse() 1422 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1423 plumbing_response.approval_workflow_approver) 1424 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1425 plumbing_response.meta) 1426 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1427 plumbing_response.rate_limit) 1428 return resp 1429 1430 def delete(self, id, timeout=None): 1431 ''' 1432 Deprecated: Delete deletes an existing approval workflow approver. 1433 ''' 1434 deadline = None if timeout is None else time.time() + timeout 1435 req = ApprovalWorkflowApproverDeleteRequest() 1436 1437 req.id = (id) 1438 tries = 0 1439 plumbing_response = None 1440 while True: 1441 t = None if deadline is None else deadline - time.time() 1442 try: 1443 plumbing_response = self.stub.Delete( 1444 req, 1445 metadata=self.parent.get_metadata( 1446 'ApprovalWorkflowApprovers.Delete', req), 1447 timeout=t) 1448 except Exception as e: 1449 if self.parent.shouldRetry(tries, e, deadline): 1450 tries += 1 1451 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1452 continue 1453 raise plumbing.convert_error_to_porcelain(e) from e 1454 break 1455 1456 resp = models.ApprovalWorkflowApproverDeleteResponse() 1457 resp.id = (plumbing_response.id) 1458 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1459 plumbing_response.rate_limit) 1460 return resp 1461 1462 def list(self, filter, *args, timeout=None): 1463 ''' 1464 Deprecated: Lists existing approval workflow approvers. 1465 ''' 1466 deadline = None if timeout is None else time.time() + timeout 1467 req = ApprovalWorkflowApproverListRequest() 1468 req.meta.CopyFrom(ListRequestMetadata()) 1469 if self.parent.page_limit > 0: 1470 req.meta.limit = self.parent.page_limit 1471 if self.parent.snapshot_datetime is not None: 1472 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1473 1474 req.filter = plumbing.quote_filter_args(filter, *args) 1475 1476 def generator(svc, req): 1477 tries = 0 1478 while True: 1479 t = None if deadline is None else deadline - time.time() 1480 try: 1481 plumbing_response = svc.stub.List( 1482 req, 1483 metadata=svc.parent.get_metadata( 1484 'ApprovalWorkflowApprovers.List', req), 1485 timeout=t) 1486 except Exception as e: 1487 if self.parent.shouldRetry(tries, e, deadline): 1488 tries += 1 1489 time.sleep( 1490 self.parent.exponentialBackoff(tries, deadline)) 1491 continue 1492 raise plumbing.convert_error_to_porcelain(e) from e 1493 tries = 0 1494 for plumbing_item in plumbing_response.approval_workflow_approvers: 1495 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1496 plumbing_item) 1497 if plumbing_response.meta.next_cursor == '': 1498 break 1499 req.meta.cursor = plumbing_response.meta.next_cursor 1500 1501 return generator(self, req) 1502 1503 1504class SnapshotApprovalWorkflowApprovers: 1505 ''' 1506 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1507 service for historical queries. 1508 ''' 1509 def __init__(self, approval_workflow_approvers): 1510 self.approval_workflow_approvers = approval_workflow_approvers 1511 1512 def get(self, id, timeout=None): 1513 ''' 1514 Deprecated: Get reads one approval workflow approver by ID. 1515 ''' 1516 return self.approval_workflow_approvers.get(id, timeout=timeout) 1517 1518 def list(self, filter, *args, timeout=None): 1519 ''' 1520 Deprecated: Lists existing approval workflow approvers. 1521 ''' 1522 return self.approval_workflow_approvers.list(filter, 1523 *args, 1524 timeout=timeout) 1525 1526 1527class ApprovalWorkflowApproversHistory: 1528 ''' 1529 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1530 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1531 ''' 1532 def __init__(self, channel, client): 1533 self.parent = client 1534 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1535 1536 def list(self, filter, *args, timeout=None): 1537 ''' 1538 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1539 ''' 1540 deadline = None if timeout is None else time.time() + timeout 1541 req = ApprovalWorkflowApproverHistoryListRequest() 1542 req.meta.CopyFrom(ListRequestMetadata()) 1543 if self.parent.page_limit > 0: 1544 req.meta.limit = self.parent.page_limit 1545 if self.parent.snapshot_datetime is not None: 1546 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1547 1548 req.filter = plumbing.quote_filter_args(filter, *args) 1549 1550 def generator(svc, req): 1551 tries = 0 1552 while True: 1553 t = None if deadline is None else deadline - time.time() 1554 try: 1555 plumbing_response = svc.stub.List( 1556 req, 1557 metadata=svc.parent.get_metadata( 1558 'ApprovalWorkflowApproversHistory.List', req), 1559 timeout=t) 1560 except Exception as e: 1561 if self.parent.shouldRetry(tries, e, deadline): 1562 tries += 1 1563 time.sleep( 1564 self.parent.exponentialBackoff(tries, deadline)) 1565 continue 1566 raise plumbing.convert_error_to_porcelain(e) from e 1567 tries = 0 1568 for plumbing_item in plumbing_response.history: 1569 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1570 plumbing_item) 1571 if plumbing_response.meta.next_cursor == '': 1572 break 1573 req.meta.cursor = plumbing_response.meta.next_cursor 1574 1575 return generator(self, req) 1576 1577 1578class ApprovalWorkflowSteps: 1579 ''' 1580 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1581 See `strongdm.models.ApprovalWorkflowStep`. 1582 ''' 1583 def __init__(self, channel, client): 1584 self.parent = client 1585 self.stub = ApprovalWorkflowStepsStub(channel) 1586 1587 def create(self, approval_workflow_step, timeout=None): 1588 ''' 1589 Deprecated: Create creates a new approval workflow step. 1590 ''' 1591 deadline = None if timeout is None else time.time() + timeout 1592 req = ApprovalWorkflowStepCreateRequest() 1593 1594 if approval_workflow_step is not None: 1595 req.approval_workflow_step.CopyFrom( 1596 plumbing.convert_approval_workflow_step_to_plumbing( 1597 approval_workflow_step)) 1598 tries = 0 1599 plumbing_response = None 1600 while True: 1601 t = None if deadline is None else deadline - time.time() 1602 try: 1603 plumbing_response = self.stub.Create( 1604 req, 1605 metadata=self.parent.get_metadata( 1606 'ApprovalWorkflowSteps.Create', req), 1607 timeout=t) 1608 except Exception as e: 1609 if self.parent.shouldRetry(tries, e, deadline): 1610 tries += 1 1611 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1612 continue 1613 raise plumbing.convert_error_to_porcelain(e) from e 1614 break 1615 1616 resp = models.ApprovalWorkflowStepCreateResponse() 1617 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1618 plumbing_response.approval_workflow_step) 1619 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1620 plumbing_response.rate_limit) 1621 return resp 1622 1623 def get(self, id, timeout=None): 1624 ''' 1625 Deprecated: Get reads one approval workflow step by ID. 1626 ''' 1627 deadline = None if timeout is None else time.time() + timeout 1628 req = ApprovalWorkflowStepGetRequest() 1629 if self.parent.snapshot_datetime is not None: 1630 req.meta.CopyFrom(GetRequestMetadata()) 1631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1632 1633 req.id = (id) 1634 tries = 0 1635 plumbing_response = None 1636 while True: 1637 t = None if deadline is None else deadline - time.time() 1638 try: 1639 plumbing_response = self.stub.Get( 1640 req, 1641 metadata=self.parent.get_metadata( 1642 'ApprovalWorkflowSteps.Get', req), 1643 timeout=t) 1644 except Exception as e: 1645 if self.parent.shouldRetry(tries, e, deadline): 1646 tries += 1 1647 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1648 continue 1649 raise plumbing.convert_error_to_porcelain(e) from e 1650 break 1651 1652 resp = models.ApprovalWorkflowStepGetResponse() 1653 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1654 plumbing_response.approval_workflow_step) 1655 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1656 plumbing_response.meta) 1657 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1658 plumbing_response.rate_limit) 1659 return resp 1660 1661 def delete(self, id, timeout=None): 1662 ''' 1663 Deprecated: Delete deletes an existing approval workflow step. 1664 ''' 1665 deadline = None if timeout is None else time.time() + timeout 1666 req = ApprovalWorkflowStepDeleteRequest() 1667 1668 req.id = (id) 1669 tries = 0 1670 plumbing_response = None 1671 while True: 1672 t = None if deadline is None else deadline - time.time() 1673 try: 1674 plumbing_response = self.stub.Delete( 1675 req, 1676 metadata=self.parent.get_metadata( 1677 'ApprovalWorkflowSteps.Delete', req), 1678 timeout=t) 1679 except Exception as e: 1680 if self.parent.shouldRetry(tries, e, deadline): 1681 tries += 1 1682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1683 continue 1684 raise plumbing.convert_error_to_porcelain(e) from e 1685 break 1686 1687 resp = models.ApprovalWorkflowStepDeleteResponse() 1688 resp.id = (plumbing_response.id) 1689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1690 plumbing_response.rate_limit) 1691 return resp 1692 1693 def list(self, filter, *args, timeout=None): 1694 ''' 1695 Deprecated: Lists existing approval workflow steps. 1696 ''' 1697 deadline = None if timeout is None else time.time() + timeout 1698 req = ApprovalWorkflowStepListRequest() 1699 req.meta.CopyFrom(ListRequestMetadata()) 1700 if self.parent.page_limit > 0: 1701 req.meta.limit = self.parent.page_limit 1702 if self.parent.snapshot_datetime is not None: 1703 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1704 1705 req.filter = plumbing.quote_filter_args(filter, *args) 1706 1707 def generator(svc, req): 1708 tries = 0 1709 while True: 1710 t = None if deadline is None else deadline - time.time() 1711 try: 1712 plumbing_response = svc.stub.List( 1713 req, 1714 metadata=svc.parent.get_metadata( 1715 'ApprovalWorkflowSteps.List', req), 1716 timeout=t) 1717 except Exception as e: 1718 if self.parent.shouldRetry(tries, e, deadline): 1719 tries += 1 1720 time.sleep( 1721 self.parent.exponentialBackoff(tries, deadline)) 1722 continue 1723 raise plumbing.convert_error_to_porcelain(e) from e 1724 tries = 0 1725 for plumbing_item in plumbing_response.approval_workflow_steps: 1726 yield plumbing.convert_approval_workflow_step_to_porcelain( 1727 plumbing_item) 1728 if plumbing_response.meta.next_cursor == '': 1729 break 1730 req.meta.cursor = plumbing_response.meta.next_cursor 1731 1732 return generator(self, req) 1733 1734 1735class SnapshotApprovalWorkflowSteps: 1736 ''' 1737 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1738 service for historical queries. 1739 ''' 1740 def __init__(self, approval_workflow_steps): 1741 self.approval_workflow_steps = approval_workflow_steps 1742 1743 def get(self, id, timeout=None): 1744 ''' 1745 Deprecated: Get reads one approval workflow step by ID. 1746 ''' 1747 return self.approval_workflow_steps.get(id, timeout=timeout) 1748 1749 def list(self, filter, *args, timeout=None): 1750 ''' 1751 Deprecated: Lists existing approval workflow steps. 1752 ''' 1753 return self.approval_workflow_steps.list(filter, 1754 *args, 1755 timeout=timeout) 1756 1757 1758class ApprovalWorkflowStepsHistory: 1759 ''' 1760 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 1761 See `strongdm.models.ApprovalWorkflowStepHistory`. 1762 ''' 1763 def __init__(self, channel, client): 1764 self.parent = client 1765 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 1766 1767 def list(self, filter, *args, timeout=None): 1768 ''' 1769 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1770 ''' 1771 deadline = None if timeout is None else time.time() + timeout 1772 req = ApprovalWorkflowStepHistoryListRequest() 1773 req.meta.CopyFrom(ListRequestMetadata()) 1774 if self.parent.page_limit > 0: 1775 req.meta.limit = self.parent.page_limit 1776 if self.parent.snapshot_datetime is not None: 1777 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1778 1779 req.filter = plumbing.quote_filter_args(filter, *args) 1780 1781 def generator(svc, req): 1782 tries = 0 1783 while True: 1784 t = None if deadline is None else deadline - time.time() 1785 try: 1786 plumbing_response = svc.stub.List( 1787 req, 1788 metadata=svc.parent.get_metadata( 1789 'ApprovalWorkflowStepsHistory.List', req), 1790 timeout=t) 1791 except Exception as e: 1792 if self.parent.shouldRetry(tries, e, deadline): 1793 tries += 1 1794 time.sleep( 1795 self.parent.exponentialBackoff(tries, deadline)) 1796 continue 1797 raise plumbing.convert_error_to_porcelain(e) from e 1798 tries = 0 1799 for plumbing_item in plumbing_response.history: 1800 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1801 plumbing_item) 1802 if plumbing_response.meta.next_cursor == '': 1803 break 1804 req.meta.cursor = plumbing_response.meta.next_cursor 1805 1806 return generator(self, req) 1807 1808 1809class ApprovalWorkflows: 1810 ''' 1811 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 1812 approvers and be approved or denied. 1813 See `strongdm.models.ApprovalWorkflow`. 1814 ''' 1815 def __init__(self, channel, client): 1816 self.parent = client 1817 self.stub = ApprovalWorkflowsStub(channel) 1818 1819 def create(self, approval_workflow, timeout=None): 1820 ''' 1821 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1822 ''' 1823 deadline = None if timeout is None else time.time() + timeout 1824 req = ApprovalWorkflowCreateRequest() 1825 1826 if approval_workflow is not None: 1827 req.approval_workflow.CopyFrom( 1828 plumbing.convert_approval_workflow_to_plumbing( 1829 approval_workflow)) 1830 tries = 0 1831 plumbing_response = None 1832 while True: 1833 t = None if deadline is None else deadline - time.time() 1834 try: 1835 plumbing_response = self.stub.Create( 1836 req, 1837 metadata=self.parent.get_metadata( 1838 'ApprovalWorkflows.Create', req), 1839 timeout=t) 1840 except Exception as e: 1841 if self.parent.shouldRetry(tries, e, deadline): 1842 tries += 1 1843 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1844 continue 1845 raise plumbing.convert_error_to_porcelain(e) from e 1846 break 1847 1848 resp = models.ApprovalWorkflowCreateResponse() 1849 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1850 plumbing_response.approval_workflow) 1851 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1852 plumbing_response.rate_limit) 1853 return resp 1854 1855 def get(self, id, timeout=None): 1856 ''' 1857 Get reads one approval workflow by ID. 1858 ''' 1859 deadline = None if timeout is None else time.time() + timeout 1860 req = ApprovalWorkflowGetRequest() 1861 if self.parent.snapshot_datetime is not None: 1862 req.meta.CopyFrom(GetRequestMetadata()) 1863 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1864 1865 req.id = (id) 1866 tries = 0 1867 plumbing_response = None 1868 while True: 1869 t = None if deadline is None else deadline - time.time() 1870 try: 1871 plumbing_response = self.stub.Get( 1872 req, 1873 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1874 req), 1875 timeout=t) 1876 except Exception as e: 1877 if self.parent.shouldRetry(tries, e, deadline): 1878 tries += 1 1879 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1880 continue 1881 raise plumbing.convert_error_to_porcelain(e) from e 1882 break 1883 1884 resp = models.ApprovalWorkflowGetResponse() 1885 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1886 plumbing_response.approval_workflow) 1887 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1888 plumbing_response.meta) 1889 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1890 plumbing_response.rate_limit) 1891 return resp 1892 1893 def delete(self, id, timeout=None): 1894 ''' 1895 Delete deletes an existing approval workflow. 1896 ''' 1897 deadline = None if timeout is None else time.time() + timeout 1898 req = ApprovalWorkflowDeleteRequest() 1899 1900 req.id = (id) 1901 tries = 0 1902 plumbing_response = None 1903 while True: 1904 t = None if deadline is None else deadline - time.time() 1905 try: 1906 plumbing_response = self.stub.Delete( 1907 req, 1908 metadata=self.parent.get_metadata( 1909 'ApprovalWorkflows.Delete', req), 1910 timeout=t) 1911 except Exception as e: 1912 if self.parent.shouldRetry(tries, e, deadline): 1913 tries += 1 1914 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1915 continue 1916 raise plumbing.convert_error_to_porcelain(e) from e 1917 break 1918 1919 resp = models.ApprovalWorkflowDeleteResponse() 1920 resp.id = (plumbing_response.id) 1921 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1922 plumbing_response.rate_limit) 1923 return resp 1924 1925 def update(self, approval_workflow, timeout=None): 1926 ''' 1927 Update updates an existing approval workflow. 1928 ''' 1929 deadline = None if timeout is None else time.time() + timeout 1930 req = ApprovalWorkflowUpdateRequest() 1931 1932 if approval_workflow is not None: 1933 req.approval_workflow.CopyFrom( 1934 plumbing.convert_approval_workflow_to_plumbing( 1935 approval_workflow)) 1936 tries = 0 1937 plumbing_response = None 1938 while True: 1939 t = None if deadline is None else deadline - time.time() 1940 try: 1941 plumbing_response = self.stub.Update( 1942 req, 1943 metadata=self.parent.get_metadata( 1944 'ApprovalWorkflows.Update', req), 1945 timeout=t) 1946 except Exception as e: 1947 if self.parent.shouldRetry(tries, e, deadline): 1948 tries += 1 1949 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1950 continue 1951 raise plumbing.convert_error_to_porcelain(e) from e 1952 break 1953 1954 resp = models.ApprovalWorkflowUpdateResponse() 1955 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1956 plumbing_response.approval_workflow) 1957 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1958 plumbing_response.rate_limit) 1959 return resp 1960 1961 def list(self, filter, *args, timeout=None): 1962 ''' 1963 Lists existing approval workflows. 1964 ''' 1965 deadline = None if timeout is None else time.time() + timeout 1966 req = ApprovalWorkflowListRequest() 1967 req.meta.CopyFrom(ListRequestMetadata()) 1968 if self.parent.page_limit > 0: 1969 req.meta.limit = self.parent.page_limit 1970 if self.parent.snapshot_datetime is not None: 1971 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1972 1973 req.filter = plumbing.quote_filter_args(filter, *args) 1974 1975 def generator(svc, req): 1976 tries = 0 1977 while True: 1978 t = None if deadline is None else deadline - time.time() 1979 try: 1980 plumbing_response = svc.stub.List( 1981 req, 1982 metadata=svc.parent.get_metadata( 1983 'ApprovalWorkflows.List', req), 1984 timeout=t) 1985 except Exception as e: 1986 if self.parent.shouldRetry(tries, e, deadline): 1987 tries += 1 1988 time.sleep( 1989 self.parent.exponentialBackoff(tries, deadline)) 1990 continue 1991 raise plumbing.convert_error_to_porcelain(e) from e 1992 tries = 0 1993 for plumbing_item in plumbing_response.approval_workflows: 1994 yield plumbing.convert_approval_workflow_to_porcelain( 1995 plumbing_item) 1996 if plumbing_response.meta.next_cursor == '': 1997 break 1998 req.meta.cursor = plumbing_response.meta.next_cursor 1999 2000 return generator(self, req) 2001 2002 2003class SnapshotApprovalWorkflows: 2004 ''' 2005 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2006 service for historical queries. 2007 ''' 2008 def __init__(self, approval_workflows): 2009 self.approval_workflows = approval_workflows 2010 2011 def get(self, id, timeout=None): 2012 ''' 2013 Get reads one approval workflow by ID. 2014 ''' 2015 return self.approval_workflows.get(id, timeout=timeout) 2016 2017 def list(self, filter, *args, timeout=None): 2018 ''' 2019 Lists existing approval workflows. 2020 ''' 2021 return self.approval_workflows.list(filter, *args, timeout=timeout) 2022 2023 2024class ApprovalWorkflowsHistory: 2025 ''' 2026 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2027 See `strongdm.models.ApprovalWorkflowHistory`. 2028 ''' 2029 def __init__(self, channel, client): 2030 self.parent = client 2031 self.stub = ApprovalWorkflowsHistoryStub(channel) 2032 2033 def list(self, filter, *args, timeout=None): 2034 ''' 2035 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2036 ''' 2037 deadline = None if timeout is None else time.time() + timeout 2038 req = ApprovalWorkflowHistoryListRequest() 2039 req.meta.CopyFrom(ListRequestMetadata()) 2040 if self.parent.page_limit > 0: 2041 req.meta.limit = self.parent.page_limit 2042 if self.parent.snapshot_datetime is not None: 2043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2044 2045 req.filter = plumbing.quote_filter_args(filter, *args) 2046 2047 def generator(svc, req): 2048 tries = 0 2049 while True: 2050 t = None if deadline is None else deadline - time.time() 2051 try: 2052 plumbing_response = svc.stub.List( 2053 req, 2054 metadata=svc.parent.get_metadata( 2055 'ApprovalWorkflowsHistory.List', req), 2056 timeout=t) 2057 except Exception as e: 2058 if self.parent.shouldRetry(tries, e, deadline): 2059 tries += 1 2060 time.sleep( 2061 self.parent.exponentialBackoff(tries, deadline)) 2062 continue 2063 raise plumbing.convert_error_to_porcelain(e) from e 2064 tries = 0 2065 for plumbing_item in plumbing_response.history: 2066 yield plumbing.convert_approval_workflow_history_to_porcelain( 2067 plumbing_item) 2068 if plumbing_response.meta.next_cursor == '': 2069 break 2070 req.meta.cursor = plumbing_response.meta.next_cursor 2071 2072 return generator(self, req) 2073 2074 2075class ControlPanel: 2076 ''' 2077 ControlPanel contains all administrative controls. 2078 ''' 2079 def __init__(self, channel, client): 2080 self.parent = client 2081 self.stub = ControlPanelStub(channel) 2082 2083 def get_sshca_public_key(self, timeout=None): 2084 ''' 2085 GetSSHCAPublicKey retrieves the SSH CA public key. 2086 ''' 2087 deadline = None if timeout is None else time.time() + timeout 2088 req = ControlPanelGetSSHCAPublicKeyRequest() 2089 2090 tries = 0 2091 plumbing_response = None 2092 while True: 2093 t = None if deadline is None else deadline - time.time() 2094 try: 2095 plumbing_response = self.stub.GetSSHCAPublicKey( 2096 req, 2097 metadata=self.parent.get_metadata( 2098 'ControlPanel.GetSSHCAPublicKey', req), 2099 timeout=t) 2100 except Exception as e: 2101 if self.parent.shouldRetry(tries, e, deadline): 2102 tries += 1 2103 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2104 continue 2105 raise plumbing.convert_error_to_porcelain(e) from e 2106 break 2107 2108 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2109 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2110 plumbing_response.meta) 2111 resp.public_key = (plumbing_response.public_key) 2112 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2113 plumbing_response.rate_limit) 2114 return resp 2115 2116 def get_rdpca_public_key(self, timeout=None): 2117 ''' 2118 GetRDPCAPublicKey retrieves the RDP CA public key. 2119 ''' 2120 deadline = None if timeout is None else time.time() + timeout 2121 req = ControlPanelGetRDPCAPublicKeyRequest() 2122 2123 tries = 0 2124 plumbing_response = None 2125 while True: 2126 t = None if deadline is None else deadline - time.time() 2127 try: 2128 plumbing_response = self.stub.GetRDPCAPublicKey( 2129 req, 2130 metadata=self.parent.get_metadata( 2131 'ControlPanel.GetRDPCAPublicKey', req), 2132 timeout=t) 2133 except Exception as e: 2134 if self.parent.shouldRetry(tries, e, deadline): 2135 tries += 1 2136 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2137 continue 2138 raise plumbing.convert_error_to_porcelain(e) from e 2139 break 2140 2141 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2142 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2143 plumbing_response.meta) 2144 resp.public_key = (plumbing_response.public_key) 2145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2146 plumbing_response.rate_limit) 2147 return resp 2148 2149 def verify_jwt(self, token, timeout=None): 2150 ''' 2151 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2152 ''' 2153 deadline = None if timeout is None else time.time() + timeout 2154 req = ControlPanelVerifyJWTRequest() 2155 2156 req.token = (token) 2157 tries = 0 2158 plumbing_response = None 2159 while True: 2160 t = None if deadline is None else deadline - time.time() 2161 try: 2162 plumbing_response = self.stub.VerifyJWT( 2163 req, 2164 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2165 req), 2166 timeout=t) 2167 except Exception as e: 2168 if self.parent.shouldRetry(tries, e, deadline): 2169 tries += 1 2170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2171 continue 2172 raise plumbing.convert_error_to_porcelain(e) from e 2173 break 2174 2175 resp = models.ControlPanelVerifyJWTResponse() 2176 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2177 plumbing_response.meta) 2178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2179 plumbing_response.rate_limit) 2180 resp.valid = (plumbing_response.valid) 2181 return resp 2182 2183 2184class Roles: 2185 ''' 2186 A Role has a list of access rules which determine which Resources the members 2187 of the Role have access to. An Account can be a member of multiple Roles via 2188 AccountAttachments. 2189 See `strongdm.models.Role`. 2190 ''' 2191 def __init__(self, channel, client): 2192 self.parent = client 2193 self.stub = RolesStub(channel) 2194 2195 def create(self, role, timeout=None): 2196 ''' 2197 Create registers a new Role. 2198 ''' 2199 deadline = None if timeout is None else time.time() + timeout 2200 req = RoleCreateRequest() 2201 2202 if role is not None: 2203 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2204 tries = 0 2205 plumbing_response = None 2206 while True: 2207 t = None if deadline is None else deadline - time.time() 2208 try: 2209 plumbing_response = self.stub.Create( 2210 req, 2211 metadata=self.parent.get_metadata('Roles.Create', req), 2212 timeout=t) 2213 except Exception as e: 2214 if self.parent.shouldRetry(tries, e, deadline): 2215 tries += 1 2216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2217 continue 2218 raise plumbing.convert_error_to_porcelain(e) from e 2219 break 2220 2221 resp = models.RoleCreateResponse() 2222 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2223 plumbing_response.meta) 2224 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2225 plumbing_response.rate_limit) 2226 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2227 return resp 2228 2229 def get(self, id, timeout=None): 2230 ''' 2231 Get reads one Role by ID. 2232 ''' 2233 deadline = None if timeout is None else time.time() + timeout 2234 req = RoleGetRequest() 2235 if self.parent.snapshot_datetime is not None: 2236 req.meta.CopyFrom(GetRequestMetadata()) 2237 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2238 2239 req.id = (id) 2240 tries = 0 2241 plumbing_response = None 2242 while True: 2243 t = None if deadline is None else deadline - time.time() 2244 try: 2245 plumbing_response = self.stub.Get( 2246 req, 2247 metadata=self.parent.get_metadata('Roles.Get', req), 2248 timeout=t) 2249 except Exception as e: 2250 if self.parent.shouldRetry(tries, e, deadline): 2251 tries += 1 2252 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2253 continue 2254 raise plumbing.convert_error_to_porcelain(e) from e 2255 break 2256 2257 resp = models.RoleGetResponse() 2258 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2259 plumbing_response.meta) 2260 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2261 plumbing_response.rate_limit) 2262 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2263 return resp 2264 2265 def update(self, role, timeout=None): 2266 ''' 2267 Update replaces all the fields of a Role by ID. 2268 ''' 2269 deadline = None if timeout is None else time.time() + timeout 2270 req = RoleUpdateRequest() 2271 2272 if role is not None: 2273 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2274 tries = 0 2275 plumbing_response = None 2276 while True: 2277 t = None if deadline is None else deadline - time.time() 2278 try: 2279 plumbing_response = self.stub.Update( 2280 req, 2281 metadata=self.parent.get_metadata('Roles.Update', req), 2282 timeout=t) 2283 except Exception as e: 2284 if self.parent.shouldRetry(tries, e, deadline): 2285 tries += 1 2286 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2287 continue 2288 raise plumbing.convert_error_to_porcelain(e) from e 2289 break 2290 2291 resp = models.RoleUpdateResponse() 2292 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2293 plumbing_response.meta) 2294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2295 plumbing_response.rate_limit) 2296 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2297 return resp 2298 2299 def delete(self, id, timeout=None): 2300 ''' 2301 Delete removes a Role by ID. 2302 ''' 2303 deadline = None if timeout is None else time.time() + timeout 2304 req = RoleDeleteRequest() 2305 2306 req.id = (id) 2307 tries = 0 2308 plumbing_response = None 2309 while True: 2310 t = None if deadline is None else deadline - time.time() 2311 try: 2312 plumbing_response = self.stub.Delete( 2313 req, 2314 metadata=self.parent.get_metadata('Roles.Delete', req), 2315 timeout=t) 2316 except Exception as e: 2317 if self.parent.shouldRetry(tries, e, deadline): 2318 tries += 1 2319 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2320 continue 2321 raise plumbing.convert_error_to_porcelain(e) from e 2322 break 2323 2324 resp = models.RoleDeleteResponse() 2325 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2326 plumbing_response.meta) 2327 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2328 plumbing_response.rate_limit) 2329 return resp 2330 2331 def list(self, filter, *args, timeout=None): 2332 ''' 2333 List gets a list of Roles matching a given set of criteria. 2334 ''' 2335 deadline = None if timeout is None else time.time() + timeout 2336 req = RoleListRequest() 2337 req.meta.CopyFrom(ListRequestMetadata()) 2338 if self.parent.page_limit > 0: 2339 req.meta.limit = self.parent.page_limit 2340 if self.parent.snapshot_datetime is not None: 2341 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2342 2343 req.filter = plumbing.quote_filter_args(filter, *args) 2344 2345 def generator(svc, req): 2346 tries = 0 2347 while True: 2348 t = None if deadline is None else deadline - time.time() 2349 try: 2350 plumbing_response = svc.stub.List( 2351 req, 2352 metadata=svc.parent.get_metadata('Roles.List', req), 2353 timeout=t) 2354 except Exception as e: 2355 if self.parent.shouldRetry(tries, e, deadline): 2356 tries += 1 2357 time.sleep( 2358 self.parent.exponentialBackoff(tries, deadline)) 2359 continue 2360 raise plumbing.convert_error_to_porcelain(e) from e 2361 tries = 0 2362 for plumbing_item in plumbing_response.roles: 2363 yield plumbing.convert_role_to_porcelain(plumbing_item) 2364 if plumbing_response.meta.next_cursor == '': 2365 break 2366 req.meta.cursor = plumbing_response.meta.next_cursor 2367 2368 return generator(self, req) 2369 2370 2371class SnapshotRoles: 2372 ''' 2373 SnapshotRoles exposes the read only methods of the Roles 2374 service for historical queries. 2375 ''' 2376 def __init__(self, roles): 2377 self.roles = roles 2378 2379 def get(self, id, timeout=None): 2380 ''' 2381 Get reads one Role by ID. 2382 ''' 2383 return self.roles.get(id, timeout=timeout) 2384 2385 def list(self, filter, *args, timeout=None): 2386 ''' 2387 List gets a list of Roles matching a given set of criteria. 2388 ''' 2389 return self.roles.list(filter, *args, timeout=timeout) 2390 2391 2392class HealthChecks: 2393 ''' 2394 HealthChecks lists the last healthcheck between each node and resource. 2395 Note the unconventional capitalization here is to prevent having a collision with GRPC 2396 See `strongdm.models.Healthcheck`. 2397 ''' 2398 def __init__(self, channel, client): 2399 self.parent = client 2400 self.stub = HealthChecksStub(channel) 2401 2402 def list(self, filter, *args, timeout=None): 2403 ''' 2404 List gets a list of Healthchecks matching a given set of criteria. 2405 ''' 2406 deadline = None if timeout is None else time.time() + timeout 2407 req = HealthcheckListRequest() 2408 req.meta.CopyFrom(ListRequestMetadata()) 2409 if self.parent.page_limit > 0: 2410 req.meta.limit = self.parent.page_limit 2411 if self.parent.snapshot_datetime is not None: 2412 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2413 2414 req.filter = plumbing.quote_filter_args(filter, *args) 2415 2416 def generator(svc, req): 2417 tries = 0 2418 while True: 2419 t = None if deadline is None else deadline - time.time() 2420 try: 2421 plumbing_response = svc.stub.List( 2422 req, 2423 metadata=svc.parent.get_metadata( 2424 'HealthChecks.List', req), 2425 timeout=t) 2426 except Exception as e: 2427 if self.parent.shouldRetry(tries, e, deadline): 2428 tries += 1 2429 time.sleep( 2430 self.parent.exponentialBackoff(tries, deadline)) 2431 continue 2432 raise plumbing.convert_error_to_porcelain(e) from e 2433 tries = 0 2434 for plumbing_item in plumbing_response.healthchecks: 2435 yield plumbing.convert_healthcheck_to_porcelain( 2436 plumbing_item) 2437 if plumbing_response.meta.next_cursor == '': 2438 break 2439 req.meta.cursor = plumbing_response.meta.next_cursor 2440 2441 return generator(self, req) 2442 2443 2444class IdentityAliases: 2445 ''' 2446 IdentityAliases assign an alias to an account within an IdentitySet. 2447 The alias is used as the username when connecting to a identity supported resource. 2448 See `strongdm.models.IdentityAlias`. 2449 ''' 2450 def __init__(self, channel, client): 2451 self.parent = client 2452 self.stub = IdentityAliasesStub(channel) 2453 2454 def create(self, identity_alias, timeout=None): 2455 ''' 2456 Create registers a new IdentityAlias. 2457 ''' 2458 deadline = None if timeout is None else time.time() + timeout 2459 req = IdentityAliasCreateRequest() 2460 2461 if identity_alias is not None: 2462 req.identity_alias.CopyFrom( 2463 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2464 tries = 0 2465 plumbing_response = None 2466 while True: 2467 t = None if deadline is None else deadline - time.time() 2468 try: 2469 plumbing_response = self.stub.Create( 2470 req, 2471 metadata=self.parent.get_metadata('IdentityAliases.Create', 2472 req), 2473 timeout=t) 2474 except Exception as e: 2475 if self.parent.shouldRetry(tries, e, deadline): 2476 tries += 1 2477 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2478 continue 2479 raise plumbing.convert_error_to_porcelain(e) from e 2480 break 2481 2482 resp = models.IdentityAliasCreateResponse() 2483 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2484 plumbing_response.identity_alias) 2485 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2486 plumbing_response.meta) 2487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2488 plumbing_response.rate_limit) 2489 return resp 2490 2491 def get(self, id, timeout=None): 2492 ''' 2493 Get reads one IdentityAlias by ID. 2494 ''' 2495 deadline = None if timeout is None else time.time() + timeout 2496 req = IdentityAliasGetRequest() 2497 if self.parent.snapshot_datetime is not None: 2498 req.meta.CopyFrom(GetRequestMetadata()) 2499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2500 2501 req.id = (id) 2502 tries = 0 2503 plumbing_response = None 2504 while True: 2505 t = None if deadline is None else deadline - time.time() 2506 try: 2507 plumbing_response = self.stub.Get( 2508 req, 2509 metadata=self.parent.get_metadata('IdentityAliases.Get', 2510 req), 2511 timeout=t) 2512 except Exception as e: 2513 if self.parent.shouldRetry(tries, e, deadline): 2514 tries += 1 2515 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2516 continue 2517 raise plumbing.convert_error_to_porcelain(e) from e 2518 break 2519 2520 resp = models.IdentityAliasGetResponse() 2521 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2522 plumbing_response.identity_alias) 2523 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2524 plumbing_response.meta) 2525 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2526 plumbing_response.rate_limit) 2527 return resp 2528 2529 def update(self, identity_alias, timeout=None): 2530 ''' 2531 Update replaces all the fields of a IdentityAlias by ID. 2532 ''' 2533 deadline = None if timeout is None else time.time() + timeout 2534 req = IdentityAliasUpdateRequest() 2535 2536 if identity_alias is not None: 2537 req.identity_alias.CopyFrom( 2538 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2539 tries = 0 2540 plumbing_response = None 2541 while True: 2542 t = None if deadline is None else deadline - time.time() 2543 try: 2544 plumbing_response = self.stub.Update( 2545 req, 2546 metadata=self.parent.get_metadata('IdentityAliases.Update', 2547 req), 2548 timeout=t) 2549 except Exception as e: 2550 if self.parent.shouldRetry(tries, e, deadline): 2551 tries += 1 2552 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2553 continue 2554 raise plumbing.convert_error_to_porcelain(e) from e 2555 break 2556 2557 resp = models.IdentityAliasUpdateResponse() 2558 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2559 plumbing_response.identity_alias) 2560 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2561 plumbing_response.meta) 2562 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2563 plumbing_response.rate_limit) 2564 return resp 2565 2566 def delete(self, id, timeout=None): 2567 ''' 2568 Delete removes a IdentityAlias by ID. 2569 ''' 2570 deadline = None if timeout is None else time.time() + timeout 2571 req = IdentityAliasDeleteRequest() 2572 2573 req.id = (id) 2574 tries = 0 2575 plumbing_response = None 2576 while True: 2577 t = None if deadline is None else deadline - time.time() 2578 try: 2579 plumbing_response = self.stub.Delete( 2580 req, 2581 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2582 req), 2583 timeout=t) 2584 except Exception as e: 2585 if self.parent.shouldRetry(tries, e, deadline): 2586 tries += 1 2587 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2588 continue 2589 raise plumbing.convert_error_to_porcelain(e) from e 2590 break 2591 2592 resp = models.IdentityAliasDeleteResponse() 2593 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2594 plumbing_response.meta) 2595 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2596 plumbing_response.rate_limit) 2597 return resp 2598 2599 def list(self, filter, *args, timeout=None): 2600 ''' 2601 List gets a list of IdentityAliases matching a given set of criteria. 2602 ''' 2603 deadline = None if timeout is None else time.time() + timeout 2604 req = IdentityAliasListRequest() 2605 req.meta.CopyFrom(ListRequestMetadata()) 2606 if self.parent.page_limit > 0: 2607 req.meta.limit = self.parent.page_limit 2608 if self.parent.snapshot_datetime is not None: 2609 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2610 2611 req.filter = plumbing.quote_filter_args(filter, *args) 2612 2613 def generator(svc, req): 2614 tries = 0 2615 while True: 2616 t = None if deadline is None else deadline - time.time() 2617 try: 2618 plumbing_response = svc.stub.List( 2619 req, 2620 metadata=svc.parent.get_metadata( 2621 'IdentityAliases.List', req), 2622 timeout=t) 2623 except Exception as e: 2624 if self.parent.shouldRetry(tries, e, deadline): 2625 tries += 1 2626 time.sleep( 2627 self.parent.exponentialBackoff(tries, deadline)) 2628 continue 2629 raise plumbing.convert_error_to_porcelain(e) from e 2630 tries = 0 2631 for plumbing_item in plumbing_response.identity_aliases: 2632 yield plumbing.convert_identity_alias_to_porcelain( 2633 plumbing_item) 2634 if plumbing_response.meta.next_cursor == '': 2635 break 2636 req.meta.cursor = plumbing_response.meta.next_cursor 2637 2638 return generator(self, req) 2639 2640 2641class SnapshotIdentityAliases: 2642 ''' 2643 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2644 service for historical queries. 2645 ''' 2646 def __init__(self, identity_aliases): 2647 self.identity_aliases = identity_aliases 2648 2649 def get(self, id, timeout=None): 2650 ''' 2651 Get reads one IdentityAlias by ID. 2652 ''' 2653 return self.identity_aliases.get(id, timeout=timeout) 2654 2655 def list(self, filter, *args, timeout=None): 2656 ''' 2657 List gets a list of IdentityAliases matching a given set of criteria. 2658 ''' 2659 return self.identity_aliases.list(filter, *args, timeout=timeout) 2660 2661 2662class IdentityAliasesHistory: 2663 ''' 2664 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2665 See `strongdm.models.IdentityAliasHistory`. 2666 ''' 2667 def __init__(self, channel, client): 2668 self.parent = client 2669 self.stub = IdentityAliasesHistoryStub(channel) 2670 2671 def list(self, filter, *args, timeout=None): 2672 ''' 2673 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2674 ''' 2675 deadline = None if timeout is None else time.time() + timeout 2676 req = IdentityAliasHistoryListRequest() 2677 req.meta.CopyFrom(ListRequestMetadata()) 2678 if self.parent.page_limit > 0: 2679 req.meta.limit = self.parent.page_limit 2680 if self.parent.snapshot_datetime is not None: 2681 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2682 2683 req.filter = plumbing.quote_filter_args(filter, *args) 2684 2685 def generator(svc, req): 2686 tries = 0 2687 while True: 2688 t = None if deadline is None else deadline - time.time() 2689 try: 2690 plumbing_response = svc.stub.List( 2691 req, 2692 metadata=svc.parent.get_metadata( 2693 'IdentityAliasesHistory.List', req), 2694 timeout=t) 2695 except Exception as e: 2696 if self.parent.shouldRetry(tries, e, deadline): 2697 tries += 1 2698 time.sleep( 2699 self.parent.exponentialBackoff(tries, deadline)) 2700 continue 2701 raise plumbing.convert_error_to_porcelain(e) from e 2702 tries = 0 2703 for plumbing_item in plumbing_response.history: 2704 yield plumbing.convert_identity_alias_history_to_porcelain( 2705 plumbing_item) 2706 if plumbing_response.meta.next_cursor == '': 2707 break 2708 req.meta.cursor = plumbing_response.meta.next_cursor 2709 2710 return generator(self, req) 2711 2712 2713class IdentitySets: 2714 ''' 2715 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2716 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2717 See `strongdm.models.IdentitySet`. 2718 ''' 2719 def __init__(self, channel, client): 2720 self.parent = client 2721 self.stub = IdentitySetsStub(channel) 2722 2723 def create(self, identity_set, timeout=None): 2724 ''' 2725 Create registers a new IdentitySet. 2726 ''' 2727 deadline = None if timeout is None else time.time() + timeout 2728 req = IdentitySetCreateRequest() 2729 2730 if identity_set is not None: 2731 req.identity_set.CopyFrom( 2732 plumbing.convert_identity_set_to_plumbing(identity_set)) 2733 tries = 0 2734 plumbing_response = None 2735 while True: 2736 t = None if deadline is None else deadline - time.time() 2737 try: 2738 plumbing_response = self.stub.Create( 2739 req, 2740 metadata=self.parent.get_metadata('IdentitySets.Create', 2741 req), 2742 timeout=t) 2743 except Exception as e: 2744 if self.parent.shouldRetry(tries, e, deadline): 2745 tries += 1 2746 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2747 continue 2748 raise plumbing.convert_error_to_porcelain(e) from e 2749 break 2750 2751 resp = models.IdentitySetCreateResponse() 2752 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2753 plumbing_response.identity_set) 2754 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2755 plumbing_response.meta) 2756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2757 plumbing_response.rate_limit) 2758 return resp 2759 2760 def get(self, id, timeout=None): 2761 ''' 2762 Get reads one IdentitySet by ID. 2763 ''' 2764 deadline = None if timeout is None else time.time() + timeout 2765 req = IdentitySetGetRequest() 2766 if self.parent.snapshot_datetime is not None: 2767 req.meta.CopyFrom(GetRequestMetadata()) 2768 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2769 2770 req.id = (id) 2771 tries = 0 2772 plumbing_response = None 2773 while True: 2774 t = None if deadline is None else deadline - time.time() 2775 try: 2776 plumbing_response = self.stub.Get( 2777 req, 2778 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2779 timeout=t) 2780 except Exception as e: 2781 if self.parent.shouldRetry(tries, e, deadline): 2782 tries += 1 2783 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2784 continue 2785 raise plumbing.convert_error_to_porcelain(e) from e 2786 break 2787 2788 resp = models.IdentitySetGetResponse() 2789 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2790 plumbing_response.identity_set) 2791 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2792 plumbing_response.meta) 2793 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2794 plumbing_response.rate_limit) 2795 return resp 2796 2797 def update(self, identity_set, timeout=None): 2798 ''' 2799 Update replaces all the fields of a IdentitySet by ID. 2800 ''' 2801 deadline = None if timeout is None else time.time() + timeout 2802 req = IdentitySetUpdateRequest() 2803 2804 if identity_set is not None: 2805 req.identity_set.CopyFrom( 2806 plumbing.convert_identity_set_to_plumbing(identity_set)) 2807 tries = 0 2808 plumbing_response = None 2809 while True: 2810 t = None if deadline is None else deadline - time.time() 2811 try: 2812 plumbing_response = self.stub.Update( 2813 req, 2814 metadata=self.parent.get_metadata('IdentitySets.Update', 2815 req), 2816 timeout=t) 2817 except Exception as e: 2818 if self.parent.shouldRetry(tries, e, deadline): 2819 tries += 1 2820 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2821 continue 2822 raise plumbing.convert_error_to_porcelain(e) from e 2823 break 2824 2825 resp = models.IdentitySetUpdateResponse() 2826 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2827 plumbing_response.identity_set) 2828 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2829 plumbing_response.meta) 2830 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2831 plumbing_response.rate_limit) 2832 return resp 2833 2834 def delete(self, id, timeout=None): 2835 ''' 2836 Delete removes a IdentitySet by ID. 2837 ''' 2838 deadline = None if timeout is None else time.time() + timeout 2839 req = IdentitySetDeleteRequest() 2840 2841 req.id = (id) 2842 tries = 0 2843 plumbing_response = None 2844 while True: 2845 t = None if deadline is None else deadline - time.time() 2846 try: 2847 plumbing_response = self.stub.Delete( 2848 req, 2849 metadata=self.parent.get_metadata('IdentitySets.Delete', 2850 req), 2851 timeout=t) 2852 except Exception as e: 2853 if self.parent.shouldRetry(tries, e, deadline): 2854 tries += 1 2855 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2856 continue 2857 raise plumbing.convert_error_to_porcelain(e) from e 2858 break 2859 2860 resp = models.IdentitySetDeleteResponse() 2861 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2862 plumbing_response.meta) 2863 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2864 plumbing_response.rate_limit) 2865 return resp 2866 2867 def list(self, filter, *args, timeout=None): 2868 ''' 2869 List gets a list of IdentitySets matching a given set of criteria. 2870 ''' 2871 deadline = None if timeout is None else time.time() + timeout 2872 req = IdentitySetListRequest() 2873 req.meta.CopyFrom(ListRequestMetadata()) 2874 if self.parent.page_limit > 0: 2875 req.meta.limit = self.parent.page_limit 2876 if self.parent.snapshot_datetime is not None: 2877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2878 2879 req.filter = plumbing.quote_filter_args(filter, *args) 2880 2881 def generator(svc, req): 2882 tries = 0 2883 while True: 2884 t = None if deadline is None else deadline - time.time() 2885 try: 2886 plumbing_response = svc.stub.List( 2887 req, 2888 metadata=svc.parent.get_metadata( 2889 'IdentitySets.List', req), 2890 timeout=t) 2891 except Exception as e: 2892 if self.parent.shouldRetry(tries, e, deadline): 2893 tries += 1 2894 time.sleep( 2895 self.parent.exponentialBackoff(tries, deadline)) 2896 continue 2897 raise plumbing.convert_error_to_porcelain(e) from e 2898 tries = 0 2899 for plumbing_item in plumbing_response.identity_sets: 2900 yield plumbing.convert_identity_set_to_porcelain( 2901 plumbing_item) 2902 if plumbing_response.meta.next_cursor == '': 2903 break 2904 req.meta.cursor = plumbing_response.meta.next_cursor 2905 2906 return generator(self, req) 2907 2908 2909class SnapshotIdentitySets: 2910 ''' 2911 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2912 service for historical queries. 2913 ''' 2914 def __init__(self, identity_sets): 2915 self.identity_sets = identity_sets 2916 2917 def get(self, id, timeout=None): 2918 ''' 2919 Get reads one IdentitySet by ID. 2920 ''' 2921 return self.identity_sets.get(id, timeout=timeout) 2922 2923 def list(self, filter, *args, timeout=None): 2924 ''' 2925 List gets a list of IdentitySets matching a given set of criteria. 2926 ''' 2927 return self.identity_sets.list(filter, *args, timeout=timeout) 2928 2929 2930class IdentitySetsHistory: 2931 ''' 2932 IdentitySetsHistory records all changes to the state of a IdentitySet. 2933 See `strongdm.models.IdentitySetHistory`. 2934 ''' 2935 def __init__(self, channel, client): 2936 self.parent = client 2937 self.stub = IdentitySetsHistoryStub(channel) 2938 2939 def list(self, filter, *args, timeout=None): 2940 ''' 2941 List gets a list of IdentitySetHistory records matching a given set of criteria. 2942 ''' 2943 deadline = None if timeout is None else time.time() + timeout 2944 req = IdentitySetHistoryListRequest() 2945 req.meta.CopyFrom(ListRequestMetadata()) 2946 if self.parent.page_limit > 0: 2947 req.meta.limit = self.parent.page_limit 2948 if self.parent.snapshot_datetime is not None: 2949 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2950 2951 req.filter = plumbing.quote_filter_args(filter, *args) 2952 2953 def generator(svc, req): 2954 tries = 0 2955 while True: 2956 t = None if deadline is None else deadline - time.time() 2957 try: 2958 plumbing_response = svc.stub.List( 2959 req, 2960 metadata=svc.parent.get_metadata( 2961 'IdentitySetsHistory.List', req), 2962 timeout=t) 2963 except Exception as e: 2964 if self.parent.shouldRetry(tries, e, deadline): 2965 tries += 1 2966 time.sleep( 2967 self.parent.exponentialBackoff(tries, deadline)) 2968 continue 2969 raise plumbing.convert_error_to_porcelain(e) from e 2970 tries = 0 2971 for plumbing_item in plumbing_response.history: 2972 yield plumbing.convert_identity_set_history_to_porcelain( 2973 plumbing_item) 2974 if plumbing_response.meta.next_cursor == '': 2975 break 2976 req.meta.cursor = plumbing_response.meta.next_cursor 2977 2978 return generator(self, req) 2979 2980 2981class ManagedSecrets: 2982 ''' 2983 ManagedSecret is a private vertical for creating, reading, updating, 2984 deleting, listing and rotating the managed secrets in the secrets engines as 2985 an authenticated user. 2986 See `strongdm.models.ManagedSecret`. 2987 ''' 2988 def __init__(self, channel, client): 2989 self.parent = client 2990 self.stub = ManagedSecretsStub(channel) 2991 2992 def list(self, filter, *args, timeout=None): 2993 ''' 2994 List returns Managed Secrets from a Secret Engine. 2995 ''' 2996 deadline = None if timeout is None else time.time() + timeout 2997 req = ManagedSecretListRequest() 2998 req.meta.CopyFrom(ListRequestMetadata()) 2999 if self.parent.page_limit > 0: 3000 req.meta.limit = self.parent.page_limit 3001 if self.parent.snapshot_datetime is not None: 3002 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3003 3004 req.filter = plumbing.quote_filter_args(filter, *args) 3005 3006 def generator(svc, req): 3007 tries = 0 3008 while True: 3009 t = None if deadline is None else deadline - time.time() 3010 try: 3011 plumbing_response = svc.stub.List( 3012 req, 3013 metadata=svc.parent.get_metadata( 3014 'ManagedSecrets.List', req), 3015 timeout=t) 3016 except Exception as e: 3017 if self.parent.shouldRetry(tries, e, deadline): 3018 tries += 1 3019 time.sleep( 3020 self.parent.exponentialBackoff(tries, deadline)) 3021 continue 3022 raise plumbing.convert_error_to_porcelain(e) from e 3023 tries = 0 3024 for plumbing_item in plumbing_response.managed_secrets: 3025 yield plumbing.convert_managed_secret_to_porcelain( 3026 plumbing_item) 3027 if plumbing_response.meta.next_cursor == '': 3028 break 3029 req.meta.cursor = plumbing_response.meta.next_cursor 3030 3031 return generator(self, req) 3032 3033 def list_by_actor(self, filter, *args, timeout=None): 3034 ''' 3035 List returns Managed Secrets for an Actor from a Secret Engine. 3036 ''' 3037 deadline = None if timeout is None else time.time() + timeout 3038 req = ManagedSecretListRequest() 3039 req.meta.CopyFrom(ListRequestMetadata()) 3040 if self.parent.page_limit > 0: 3041 req.meta.limit = self.parent.page_limit 3042 if self.parent.snapshot_datetime is not None: 3043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3044 3045 req.filter = plumbing.quote_filter_args(filter, *args) 3046 3047 def generator(svc, req): 3048 tries = 0 3049 while True: 3050 t = None if deadline is None else deadline - time.time() 3051 try: 3052 plumbing_response = svc.stub.ListByActor( 3053 req, 3054 metadata=svc.parent.get_metadata( 3055 'ManagedSecrets.ListByActor', req), 3056 timeout=t) 3057 except Exception as e: 3058 if self.parent.shouldRetry(tries, e, deadline): 3059 tries += 1 3060 time.sleep( 3061 self.parent.exponentialBackoff(tries, deadline)) 3062 continue 3063 raise plumbing.convert_error_to_porcelain(e) from e 3064 tries = 0 3065 for plumbing_item in plumbing_response.managed_secrets: 3066 yield plumbing.convert_managed_secret_to_porcelain( 3067 plumbing_item) 3068 if plumbing_response.meta.next_cursor == '': 3069 break 3070 req.meta.cursor = plumbing_response.meta.next_cursor 3071 3072 return generator(self, req) 3073 3074 def create(self, managed_secret, timeout=None): 3075 ''' 3076 Create creates a Managed Secret 3077 ''' 3078 deadline = None if timeout is None else time.time() + timeout 3079 req = ManagedSecretCreateRequest() 3080 3081 if managed_secret is not None: 3082 req.managed_secret.CopyFrom( 3083 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3084 tries = 0 3085 plumbing_response = None 3086 while True: 3087 t = None if deadline is None else deadline - time.time() 3088 try: 3089 plumbing_response = self.stub.Create( 3090 req, 3091 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3092 req), 3093 timeout=t) 3094 except Exception as e: 3095 if self.parent.shouldRetry(tries, e, deadline): 3096 tries += 1 3097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3098 continue 3099 raise plumbing.convert_error_to_porcelain(e) from e 3100 break 3101 3102 resp = models.ManagedSecretCreateResponse() 3103 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3104 plumbing_response.managed_secret) 3105 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3106 plumbing_response.meta) 3107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3108 plumbing_response.rate_limit) 3109 return resp 3110 3111 def update(self, managed_secret, timeout=None): 3112 ''' 3113 Update updates a Managed Secret 3114 ''' 3115 deadline = None if timeout is None else time.time() + timeout 3116 req = ManagedSecretUpdateRequest() 3117 3118 if managed_secret is not None: 3119 req.managed_secret.CopyFrom( 3120 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3121 tries = 0 3122 plumbing_response = None 3123 while True: 3124 t = None if deadline is None else deadline - time.time() 3125 try: 3126 plumbing_response = self.stub.Update( 3127 req, 3128 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3129 req), 3130 timeout=t) 3131 except Exception as e: 3132 if self.parent.shouldRetry(tries, e, deadline): 3133 tries += 1 3134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3135 continue 3136 raise plumbing.convert_error_to_porcelain(e) from e 3137 break 3138 3139 resp = models.ManagedSecretUpdateResponse() 3140 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3141 plumbing_response.managed_secret) 3142 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3143 plumbing_response.meta) 3144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3145 plumbing_response.rate_limit) 3146 return resp 3147 3148 def rotate(self, id, timeout=None): 3149 ''' 3150 Rotate forces rotation of Managed Secret 3151 ''' 3152 deadline = None if timeout is None else time.time() + timeout 3153 req = ManagedSecretRotateRequest() 3154 3155 req.id = (id) 3156 tries = 0 3157 plumbing_response = None 3158 while True: 3159 t = None if deadline is None else deadline - time.time() 3160 try: 3161 plumbing_response = self.stub.Rotate( 3162 req, 3163 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3164 req), 3165 timeout=t) 3166 except Exception as e: 3167 if self.parent.shouldRetry(tries, e, deadline): 3168 tries += 1 3169 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3170 continue 3171 raise plumbing.convert_error_to_porcelain(e) from e 3172 break 3173 3174 resp = models.ManagedSecretRotateResponse() 3175 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3176 plumbing_response.meta) 3177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3178 plumbing_response.rate_limit) 3179 return resp 3180 3181 def delete(self, id, timeout=None): 3182 ''' 3183 Delete deletes a Managed Secret 3184 ''' 3185 deadline = None if timeout is None else time.time() + timeout 3186 req = ManagedSecretDeleteRequest() 3187 3188 req.id = (id) 3189 tries = 0 3190 plumbing_response = None 3191 while True: 3192 t = None if deadline is None else deadline - time.time() 3193 try: 3194 plumbing_response = self.stub.Delete( 3195 req, 3196 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3197 req), 3198 timeout=t) 3199 except Exception as e: 3200 if self.parent.shouldRetry(tries, e, deadline): 3201 tries += 1 3202 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3203 continue 3204 raise plumbing.convert_error_to_porcelain(e) from e 3205 break 3206 3207 resp = models.ManagedSecretDeleteResponse() 3208 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3209 plumbing_response.rate_limit) 3210 return resp 3211 3212 def force_delete(self, id, timeout=None): 3213 ''' 3214 ForceDelete deletes a Managed Secret regardless of errors on external system 3215 ''' 3216 deadline = None if timeout is None else time.time() + timeout 3217 req = ManagedSecretDeleteRequest() 3218 3219 req.id = (id) 3220 tries = 0 3221 plumbing_response = None 3222 while True: 3223 t = None if deadline is None else deadline - time.time() 3224 try: 3225 plumbing_response = self.stub.ForceDelete( 3226 req, 3227 metadata=self.parent.get_metadata( 3228 'ManagedSecrets.ForceDelete', req), 3229 timeout=t) 3230 except Exception as e: 3231 if self.parent.shouldRetry(tries, e, deadline): 3232 tries += 1 3233 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3234 continue 3235 raise plumbing.convert_error_to_porcelain(e) from e 3236 break 3237 3238 resp = models.ManagedSecretDeleteResponse() 3239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3240 plumbing_response.rate_limit) 3241 return resp 3242 3243 def get(self, id, timeout=None): 3244 ''' 3245 Get gets details of a Managed Secret without sensitive data 3246 ''' 3247 deadline = None if timeout is None else time.time() + timeout 3248 req = ManagedSecretGetRequest() 3249 if self.parent.snapshot_datetime is not None: 3250 req.meta.CopyFrom(GetRequestMetadata()) 3251 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3252 3253 req.id = (id) 3254 tries = 0 3255 plumbing_response = None 3256 while True: 3257 t = None if deadline is None else deadline - time.time() 3258 try: 3259 plumbing_response = self.stub.Get( 3260 req, 3261 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3262 req), 3263 timeout=t) 3264 except Exception as e: 3265 if self.parent.shouldRetry(tries, e, deadline): 3266 tries += 1 3267 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3268 continue 3269 raise plumbing.convert_error_to_porcelain(e) from e 3270 break 3271 3272 resp = models.ManagedSecretGetResponse() 3273 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3274 plumbing_response.managed_secret) 3275 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3276 plumbing_response.meta) 3277 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3278 plumbing_response.rate_limit) 3279 return resp 3280 3281 def retrieve(self, id, public_key, timeout=None): 3282 ''' 3283 Retrieve returns Managed Secret with sensitive data 3284 ''' 3285 deadline = None if timeout is None else time.time() + timeout 3286 req = ManagedSecretRetrieveRequest() 3287 3288 req.id = (id) 3289 req.public_key = (public_key) 3290 tries = 0 3291 plumbing_response = None 3292 while True: 3293 t = None if deadline is None else deadline - time.time() 3294 try: 3295 plumbing_response = self.stub.Retrieve( 3296 req, 3297 metadata=self.parent.get_metadata( 3298 'ManagedSecrets.Retrieve', req), 3299 timeout=t) 3300 except Exception as e: 3301 if self.parent.shouldRetry(tries, e, deadline): 3302 tries += 1 3303 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3304 continue 3305 raise plumbing.convert_error_to_porcelain(e) from e 3306 break 3307 3308 resp = models.ManagedSecretRetrieveResponse() 3309 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3310 plumbing_response.managed_secret) 3311 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3312 plumbing_response.meta) 3313 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3314 plumbing_response.rate_limit) 3315 return resp 3316 3317 def validate(self, id, timeout=None): 3318 ''' 3319 Validate returns the result of testing the stored credential against the 3320 secret engine. 3321 ''' 3322 deadline = None if timeout is None else time.time() + timeout 3323 req = ManagedSecretValidateRequest() 3324 3325 req.id = (id) 3326 tries = 0 3327 plumbing_response = None 3328 while True: 3329 t = None if deadline is None else deadline - time.time() 3330 try: 3331 plumbing_response = self.stub.Validate( 3332 req, 3333 metadata=self.parent.get_metadata( 3334 'ManagedSecrets.Validate', req), 3335 timeout=t) 3336 except Exception as e: 3337 if self.parent.shouldRetry(tries, e, deadline): 3338 tries += 1 3339 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3340 continue 3341 raise plumbing.convert_error_to_porcelain(e) from e 3342 break 3343 3344 resp = models.ManagedSecretValidateResponse() 3345 resp.invalid_info = (plumbing_response.invalid_info) 3346 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3347 plumbing_response.meta) 3348 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3349 plumbing_response.rate_limit) 3350 resp.valid = (plumbing_response.valid) 3351 return resp 3352 3353 def logs(self, filter, *args, timeout=None): 3354 ''' 3355 Logs returns the audit records for the managed secret. This may be replaced 3356 in the future. 3357 ''' 3358 deadline = None if timeout is None else time.time() + timeout 3359 req = ManagedSecretLogsRequest() 3360 req.meta.CopyFrom(ListRequestMetadata()) 3361 if self.parent.page_limit > 0: 3362 req.meta.limit = self.parent.page_limit 3363 if self.parent.snapshot_datetime is not None: 3364 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3365 3366 req.filter = plumbing.quote_filter_args(filter, *args) 3367 3368 def generator(svc, req): 3369 tries = 0 3370 while True: 3371 t = None if deadline is None else deadline - time.time() 3372 try: 3373 plumbing_response = svc.stub.Logs( 3374 req, 3375 metadata=svc.parent.get_metadata( 3376 'ManagedSecrets.Logs', req), 3377 timeout=t) 3378 except Exception as e: 3379 if self.parent.shouldRetry(tries, e, deadline): 3380 tries += 1 3381 time.sleep( 3382 self.parent.exponentialBackoff(tries, deadline)) 3383 continue 3384 raise plumbing.convert_error_to_porcelain(e) from e 3385 tries = 0 3386 for plumbing_item in plumbing_response.managed_secret_logs: 3387 yield plumbing.convert_managed_secret_log_to_porcelain( 3388 plumbing_item) 3389 if plumbing_response.meta.next_cursor == '': 3390 break 3391 req.meta.cursor = plumbing_response.meta.next_cursor 3392 3393 return generator(self, req) 3394 3395 3396class Nodes: 3397 ''' 3398 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3399 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3400 - **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. 3401 See: 3402 `strongdm.models.Gateway` 3403 `strongdm.models.ProxyCluster` 3404 `strongdm.models.Relay` 3405 ''' 3406 def __init__(self, channel, client): 3407 self.parent = client 3408 self.stub = NodesStub(channel) 3409 3410 def create(self, node, timeout=None): 3411 ''' 3412 Create registers a new Node. 3413 ''' 3414 deadline = None if timeout is None else time.time() + timeout 3415 req = NodeCreateRequest() 3416 3417 if node is not None: 3418 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3419 tries = 0 3420 plumbing_response = None 3421 while True: 3422 t = None if deadline is None else deadline - time.time() 3423 try: 3424 plumbing_response = self.stub.Create( 3425 req, 3426 metadata=self.parent.get_metadata('Nodes.Create', req), 3427 timeout=t) 3428 except Exception as e: 3429 if self.parent.shouldRetry(tries, e, deadline): 3430 tries += 1 3431 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3432 continue 3433 raise plumbing.convert_error_to_porcelain(e) from e 3434 break 3435 3436 resp = models.NodeCreateResponse() 3437 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3438 plumbing_response.meta) 3439 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3440 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3441 plumbing_response.rate_limit) 3442 resp.token = (plumbing_response.token) 3443 return resp 3444 3445 def get(self, id, timeout=None): 3446 ''' 3447 Get reads one Node by ID. 3448 ''' 3449 deadline = None if timeout is None else time.time() + timeout 3450 req = NodeGetRequest() 3451 if self.parent.snapshot_datetime is not None: 3452 req.meta.CopyFrom(GetRequestMetadata()) 3453 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3454 3455 req.id = (id) 3456 tries = 0 3457 plumbing_response = None 3458 while True: 3459 t = None if deadline is None else deadline - time.time() 3460 try: 3461 plumbing_response = self.stub.Get( 3462 req, 3463 metadata=self.parent.get_metadata('Nodes.Get', req), 3464 timeout=t) 3465 except Exception as e: 3466 if self.parent.shouldRetry(tries, e, deadline): 3467 tries += 1 3468 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3469 continue 3470 raise plumbing.convert_error_to_porcelain(e) from e 3471 break 3472 3473 resp = models.NodeGetResponse() 3474 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3475 plumbing_response.meta) 3476 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3477 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3478 plumbing_response.rate_limit) 3479 return resp 3480 3481 def update(self, node, timeout=None): 3482 ''' 3483 Update replaces all the fields of a Node by ID. 3484 ''' 3485 deadline = None if timeout is None else time.time() + timeout 3486 req = NodeUpdateRequest() 3487 3488 if node is not None: 3489 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3490 tries = 0 3491 plumbing_response = None 3492 while True: 3493 t = None if deadline is None else deadline - time.time() 3494 try: 3495 plumbing_response = self.stub.Update( 3496 req, 3497 metadata=self.parent.get_metadata('Nodes.Update', req), 3498 timeout=t) 3499 except Exception as e: 3500 if self.parent.shouldRetry(tries, e, deadline): 3501 tries += 1 3502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3503 continue 3504 raise plumbing.convert_error_to_porcelain(e) from e 3505 break 3506 3507 resp = models.NodeUpdateResponse() 3508 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3509 plumbing_response.meta) 3510 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3511 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3512 plumbing_response.rate_limit) 3513 return resp 3514 3515 def delete(self, id, timeout=None): 3516 ''' 3517 Delete removes a Node by ID. 3518 ''' 3519 deadline = None if timeout is None else time.time() + timeout 3520 req = NodeDeleteRequest() 3521 3522 req.id = (id) 3523 tries = 0 3524 plumbing_response = None 3525 while True: 3526 t = None if deadline is None else deadline - time.time() 3527 try: 3528 plumbing_response = self.stub.Delete( 3529 req, 3530 metadata=self.parent.get_metadata('Nodes.Delete', req), 3531 timeout=t) 3532 except Exception as e: 3533 if self.parent.shouldRetry(tries, e, deadline): 3534 tries += 1 3535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3536 continue 3537 raise plumbing.convert_error_to_porcelain(e) from e 3538 break 3539 3540 resp = models.NodeDeleteResponse() 3541 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3542 plumbing_response.meta) 3543 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3544 plumbing_response.rate_limit) 3545 return resp 3546 3547 def list(self, filter, *args, timeout=None): 3548 ''' 3549 List gets a list of Nodes matching a given set of criteria. 3550 ''' 3551 deadline = None if timeout is None else time.time() + timeout 3552 req = NodeListRequest() 3553 req.meta.CopyFrom(ListRequestMetadata()) 3554 if self.parent.page_limit > 0: 3555 req.meta.limit = self.parent.page_limit 3556 if self.parent.snapshot_datetime is not None: 3557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3558 3559 req.filter = plumbing.quote_filter_args(filter, *args) 3560 3561 def generator(svc, req): 3562 tries = 0 3563 while True: 3564 t = None if deadline is None else deadline - time.time() 3565 try: 3566 plumbing_response = svc.stub.List( 3567 req, 3568 metadata=svc.parent.get_metadata('Nodes.List', req), 3569 timeout=t) 3570 except Exception as e: 3571 if self.parent.shouldRetry(tries, e, deadline): 3572 tries += 1 3573 time.sleep( 3574 self.parent.exponentialBackoff(tries, deadline)) 3575 continue 3576 raise plumbing.convert_error_to_porcelain(e) from e 3577 tries = 0 3578 for plumbing_item in plumbing_response.nodes: 3579 yield plumbing.convert_node_to_porcelain(plumbing_item) 3580 if plumbing_response.meta.next_cursor == '': 3581 break 3582 req.meta.cursor = plumbing_response.meta.next_cursor 3583 3584 return generator(self, req) 3585 3586 3587class SnapshotNodes: 3588 ''' 3589 SnapshotNodes exposes the read only methods of the Nodes 3590 service for historical queries. 3591 ''' 3592 def __init__(self, nodes): 3593 self.nodes = nodes 3594 3595 def get(self, id, timeout=None): 3596 ''' 3597 Get reads one Node by ID. 3598 ''' 3599 return self.nodes.get(id, timeout=timeout) 3600 3601 def list(self, filter, *args, timeout=None): 3602 ''' 3603 List gets a list of Nodes matching a given set of criteria. 3604 ''' 3605 return self.nodes.list(filter, *args, timeout=timeout) 3606 3607 3608class NodesHistory: 3609 ''' 3610 NodesHistory records all changes to the state of a Node. 3611 See `strongdm.models.NodeHistory`. 3612 ''' 3613 def __init__(self, channel, client): 3614 self.parent = client 3615 self.stub = NodesHistoryStub(channel) 3616 3617 def list(self, filter, *args, timeout=None): 3618 ''' 3619 List gets a list of NodeHistory records matching a given set of criteria. 3620 ''' 3621 deadline = None if timeout is None else time.time() + timeout 3622 req = NodeHistoryListRequest() 3623 req.meta.CopyFrom(ListRequestMetadata()) 3624 if self.parent.page_limit > 0: 3625 req.meta.limit = self.parent.page_limit 3626 if self.parent.snapshot_datetime is not None: 3627 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3628 3629 req.filter = plumbing.quote_filter_args(filter, *args) 3630 3631 def generator(svc, req): 3632 tries = 0 3633 while True: 3634 t = None if deadline is None else deadline - time.time() 3635 try: 3636 plumbing_response = svc.stub.List( 3637 req, 3638 metadata=svc.parent.get_metadata( 3639 'NodesHistory.List', req), 3640 timeout=t) 3641 except Exception as e: 3642 if self.parent.shouldRetry(tries, e, deadline): 3643 tries += 1 3644 time.sleep( 3645 self.parent.exponentialBackoff(tries, deadline)) 3646 continue 3647 raise plumbing.convert_error_to_porcelain(e) from e 3648 tries = 0 3649 for plumbing_item in plumbing_response.history: 3650 yield plumbing.convert_node_history_to_porcelain( 3651 plumbing_item) 3652 if plumbing_response.meta.next_cursor == '': 3653 break 3654 req.meta.cursor = plumbing_response.meta.next_cursor 3655 3656 return generator(self, req) 3657 3658 3659class OrganizationHistory: 3660 ''' 3661 OrganizationHistory records all changes to the state of an Organization. 3662 See `strongdm.models.OrganizationHistoryRecord`. 3663 ''' 3664 def __init__(self, channel, client): 3665 self.parent = client 3666 self.stub = OrganizationHistoryStub(channel) 3667 3668 def list(self, filter, *args, timeout=None): 3669 ''' 3670 List gets a list of OrganizationHistory records matching a given set of criteria. 3671 ''' 3672 deadline = None if timeout is None else time.time() + timeout 3673 req = OrganizationHistoryListRequest() 3674 req.meta.CopyFrom(ListRequestMetadata()) 3675 if self.parent.page_limit > 0: 3676 req.meta.limit = self.parent.page_limit 3677 if self.parent.snapshot_datetime is not None: 3678 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3679 3680 req.filter = plumbing.quote_filter_args(filter, *args) 3681 3682 def generator(svc, req): 3683 tries = 0 3684 while True: 3685 t = None if deadline is None else deadline - time.time() 3686 try: 3687 plumbing_response = svc.stub.List( 3688 req, 3689 metadata=svc.parent.get_metadata( 3690 'OrganizationHistory.List', req), 3691 timeout=t) 3692 except Exception as e: 3693 if self.parent.shouldRetry(tries, e, deadline): 3694 tries += 1 3695 time.sleep( 3696 self.parent.exponentialBackoff(tries, deadline)) 3697 continue 3698 raise plumbing.convert_error_to_porcelain(e) from e 3699 tries = 0 3700 for plumbing_item in plumbing_response.history: 3701 yield plumbing.convert_organization_history_record_to_porcelain( 3702 plumbing_item) 3703 if plumbing_response.meta.next_cursor == '': 3704 break 3705 req.meta.cursor = plumbing_response.meta.next_cursor 3706 3707 return generator(self, req) 3708 3709 3710class PeeringGroupNodes: 3711 ''' 3712 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3713 See `strongdm.models.PeeringGroupNode`. 3714 ''' 3715 def __init__(self, channel, client): 3716 self.parent = client 3717 self.stub = PeeringGroupNodesStub(channel) 3718 3719 def create(self, peering_group_node, timeout=None): 3720 ''' 3721 Create attaches a Node to a PeeringGroup 3722 ''' 3723 deadline = None if timeout is None else time.time() + timeout 3724 req = PeeringGroupNodeCreateRequest() 3725 3726 if peering_group_node is not None: 3727 req.peering_group_node.CopyFrom( 3728 plumbing.convert_peering_group_node_to_plumbing( 3729 peering_group_node)) 3730 tries = 0 3731 plumbing_response = None 3732 while True: 3733 t = None if deadline is None else deadline - time.time() 3734 try: 3735 plumbing_response = self.stub.Create( 3736 req, 3737 metadata=self.parent.get_metadata( 3738 'PeeringGroupNodes.Create', req), 3739 timeout=t) 3740 except Exception as e: 3741 if self.parent.shouldRetry(tries, e, deadline): 3742 tries += 1 3743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3744 continue 3745 raise plumbing.convert_error_to_porcelain(e) from e 3746 break 3747 3748 resp = models.PeeringGroupNodeCreateResponse() 3749 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3750 plumbing_response.meta) 3751 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3752 plumbing_response.peering_group_node) 3753 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3754 plumbing_response.rate_limit) 3755 return resp 3756 3757 def delete(self, id, timeout=None): 3758 ''' 3759 Delete detaches a Node to a PeeringGroup. 3760 ''' 3761 deadline = None if timeout is None else time.time() + timeout 3762 req = PeeringGroupNodeDeleteRequest() 3763 3764 req.id = (id) 3765 tries = 0 3766 plumbing_response = None 3767 while True: 3768 t = None if deadline is None else deadline - time.time() 3769 try: 3770 plumbing_response = self.stub.Delete( 3771 req, 3772 metadata=self.parent.get_metadata( 3773 'PeeringGroupNodes.Delete', req), 3774 timeout=t) 3775 except Exception as e: 3776 if self.parent.shouldRetry(tries, e, deadline): 3777 tries += 1 3778 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3779 continue 3780 raise plumbing.convert_error_to_porcelain(e) from e 3781 break 3782 3783 resp = models.PeeringGroupNodeDeleteResponse() 3784 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3785 plumbing_response.meta) 3786 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3787 plumbing_response.rate_limit) 3788 return resp 3789 3790 def get(self, id, timeout=None): 3791 ''' 3792 Get reads the information of one peering group to node attachment. 3793 ''' 3794 deadline = None if timeout is None else time.time() + timeout 3795 req = PeeringGroupNodeGetRequest() 3796 if self.parent.snapshot_datetime is not None: 3797 req.meta.CopyFrom(GetRequestMetadata()) 3798 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3799 3800 req.id = (id) 3801 tries = 0 3802 plumbing_response = None 3803 while True: 3804 t = None if deadline is None else deadline - time.time() 3805 try: 3806 plumbing_response = self.stub.Get( 3807 req, 3808 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3809 req), 3810 timeout=t) 3811 except Exception as e: 3812 if self.parent.shouldRetry(tries, e, deadline): 3813 tries += 1 3814 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3815 continue 3816 raise plumbing.convert_error_to_porcelain(e) from e 3817 break 3818 3819 resp = models.PeeringGroupNodeGetResponse() 3820 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3821 plumbing_response.meta) 3822 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3823 plumbing_response.peering_group_node) 3824 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3825 plumbing_response.rate_limit) 3826 return resp 3827 3828 def list(self, filter, *args, timeout=None): 3829 ''' 3830 List gets a list of peering group node attachments. 3831 ''' 3832 deadline = None if timeout is None else time.time() + timeout 3833 req = PeeringGroupNodeListRequest() 3834 req.meta.CopyFrom(ListRequestMetadata()) 3835 if self.parent.page_limit > 0: 3836 req.meta.limit = self.parent.page_limit 3837 if self.parent.snapshot_datetime is not None: 3838 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3839 3840 req.filter = plumbing.quote_filter_args(filter, *args) 3841 3842 def generator(svc, req): 3843 tries = 0 3844 while True: 3845 t = None if deadline is None else deadline - time.time() 3846 try: 3847 plumbing_response = svc.stub.List( 3848 req, 3849 metadata=svc.parent.get_metadata( 3850 'PeeringGroupNodes.List', req), 3851 timeout=t) 3852 except Exception as e: 3853 if self.parent.shouldRetry(tries, e, deadline): 3854 tries += 1 3855 time.sleep( 3856 self.parent.exponentialBackoff(tries, deadline)) 3857 continue 3858 raise plumbing.convert_error_to_porcelain(e) from e 3859 tries = 0 3860 for plumbing_item in plumbing_response.peering_group_nodes: 3861 yield plumbing.convert_peering_group_node_to_porcelain( 3862 plumbing_item) 3863 if plumbing_response.meta.next_cursor == '': 3864 break 3865 req.meta.cursor = plumbing_response.meta.next_cursor 3866 3867 return generator(self, req) 3868 3869 3870class PeeringGroupPeers: 3871 ''' 3872 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3873 See `strongdm.models.PeeringGroupPeer`. 3874 ''' 3875 def __init__(self, channel, client): 3876 self.parent = client 3877 self.stub = PeeringGroupPeersStub(channel) 3878 3879 def create(self, peering_group_peer, timeout=None): 3880 ''' 3881 Create links two peering groups. 3882 ''' 3883 deadline = None if timeout is None else time.time() + timeout 3884 req = PeeringGroupPeerCreateRequest() 3885 3886 if peering_group_peer is not None: 3887 req.peering_group_peer.CopyFrom( 3888 plumbing.convert_peering_group_peer_to_plumbing( 3889 peering_group_peer)) 3890 tries = 0 3891 plumbing_response = None 3892 while True: 3893 t = None if deadline is None else deadline - time.time() 3894 try: 3895 plumbing_response = self.stub.Create( 3896 req, 3897 metadata=self.parent.get_metadata( 3898 'PeeringGroupPeers.Create', req), 3899 timeout=t) 3900 except Exception as e: 3901 if self.parent.shouldRetry(tries, e, deadline): 3902 tries += 1 3903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3904 continue 3905 raise plumbing.convert_error_to_porcelain(e) from e 3906 break 3907 3908 resp = models.PeeringGroupPeerCreateResponse() 3909 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3910 plumbing_response.meta) 3911 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3912 plumbing_response.peering_group_peer) 3913 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3914 plumbing_response.rate_limit) 3915 return resp 3916 3917 def delete(self, id, timeout=None): 3918 ''' 3919 Delete unlinks two peering groups. 3920 ''' 3921 deadline = None if timeout is None else time.time() + timeout 3922 req = PeeringGroupPeerDeleteRequest() 3923 3924 req.id = (id) 3925 tries = 0 3926 plumbing_response = None 3927 while True: 3928 t = None if deadline is None else deadline - time.time() 3929 try: 3930 plumbing_response = self.stub.Delete( 3931 req, 3932 metadata=self.parent.get_metadata( 3933 'PeeringGroupPeers.Delete', req), 3934 timeout=t) 3935 except Exception as e: 3936 if self.parent.shouldRetry(tries, e, deadline): 3937 tries += 1 3938 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3939 continue 3940 raise plumbing.convert_error_to_porcelain(e) from e 3941 break 3942 3943 resp = models.PeeringGroupPeerDeleteResponse() 3944 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3945 plumbing_response.meta) 3946 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3947 plumbing_response.rate_limit) 3948 return resp 3949 3950 def get(self, id, timeout=None): 3951 ''' 3952 Get reads the information of one peering group link. 3953 ''' 3954 deadline = None if timeout is None else time.time() + timeout 3955 req = PeeringGroupPeerGetRequest() 3956 if self.parent.snapshot_datetime is not None: 3957 req.meta.CopyFrom(GetRequestMetadata()) 3958 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3959 3960 req.id = (id) 3961 tries = 0 3962 plumbing_response = None 3963 while True: 3964 t = None if deadline is None else deadline - time.time() 3965 try: 3966 plumbing_response = self.stub.Get( 3967 req, 3968 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3969 req), 3970 timeout=t) 3971 except Exception as e: 3972 if self.parent.shouldRetry(tries, e, deadline): 3973 tries += 1 3974 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3975 continue 3976 raise plumbing.convert_error_to_porcelain(e) from e 3977 break 3978 3979 resp = models.PeeringGroupPeerGetResponse() 3980 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3981 plumbing_response.meta) 3982 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3983 plumbing_response.peering_group_peer) 3984 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3985 plumbing_response.rate_limit) 3986 return resp 3987 3988 def list(self, filter, *args, timeout=None): 3989 ''' 3990 List gets a list of peering group links. 3991 ''' 3992 deadline = None if timeout is None else time.time() + timeout 3993 req = PeeringGroupPeerListRequest() 3994 req.meta.CopyFrom(ListRequestMetadata()) 3995 if self.parent.page_limit > 0: 3996 req.meta.limit = self.parent.page_limit 3997 if self.parent.snapshot_datetime is not None: 3998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3999 4000 req.filter = plumbing.quote_filter_args(filter, *args) 4001 4002 def generator(svc, req): 4003 tries = 0 4004 while True: 4005 t = None if deadline is None else deadline - time.time() 4006 try: 4007 plumbing_response = svc.stub.List( 4008 req, 4009 metadata=svc.parent.get_metadata( 4010 'PeeringGroupPeers.List', req), 4011 timeout=t) 4012 except Exception as e: 4013 if self.parent.shouldRetry(tries, e, deadline): 4014 tries += 1 4015 time.sleep( 4016 self.parent.exponentialBackoff(tries, deadline)) 4017 continue 4018 raise plumbing.convert_error_to_porcelain(e) from e 4019 tries = 0 4020 for plumbing_item in plumbing_response.peering_group_peers: 4021 yield plumbing.convert_peering_group_peer_to_porcelain( 4022 plumbing_item) 4023 if plumbing_response.meta.next_cursor == '': 4024 break 4025 req.meta.cursor = plumbing_response.meta.next_cursor 4026 4027 return generator(self, req) 4028 4029 4030class PeeringGroupResources: 4031 ''' 4032 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4033 See `strongdm.models.PeeringGroupResource`. 4034 ''' 4035 def __init__(self, channel, client): 4036 self.parent = client 4037 self.stub = PeeringGroupResourcesStub(channel) 4038 4039 def create(self, peering_group_resource, timeout=None): 4040 ''' 4041 Create attaches a Resource to a PeeringGroup 4042 ''' 4043 deadline = None if timeout is None else time.time() + timeout 4044 req = PeeringGroupResourceCreateRequest() 4045 4046 if peering_group_resource is not None: 4047 req.peering_group_resource.CopyFrom( 4048 plumbing.convert_peering_group_resource_to_plumbing( 4049 peering_group_resource)) 4050 tries = 0 4051 plumbing_response = None 4052 while True: 4053 t = None if deadline is None else deadline - time.time() 4054 try: 4055 plumbing_response = self.stub.Create( 4056 req, 4057 metadata=self.parent.get_metadata( 4058 'PeeringGroupResources.Create', req), 4059 timeout=t) 4060 except Exception as e: 4061 if self.parent.shouldRetry(tries, e, deadline): 4062 tries += 1 4063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4064 continue 4065 raise plumbing.convert_error_to_porcelain(e) from e 4066 break 4067 4068 resp = models.PeeringGroupResourceCreateResponse() 4069 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4070 plumbing_response.meta) 4071 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4072 plumbing_response.peering_group_resource) 4073 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4074 plumbing_response.rate_limit) 4075 return resp 4076 4077 def delete(self, id, timeout=None): 4078 ''' 4079 Delete detaches a Resource to a PeeringGroup 4080 ''' 4081 deadline = None if timeout is None else time.time() + timeout 4082 req = PeeringGroupResourceDeleteRequest() 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.Delete( 4091 req, 4092 metadata=self.parent.get_metadata( 4093 'PeeringGroupResources.Delete', 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.PeeringGroupResourceDeleteResponse() 4104 resp.meta = plumbing.convert_delete_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 return resp 4109 4110 def get(self, id, timeout=None): 4111 ''' 4112 Get reads the information of one peering group to resource attachment. 4113 ''' 4114 deadline = None if timeout is None else time.time() + timeout 4115 req = PeeringGroupResourceGetRequest() 4116 if self.parent.snapshot_datetime is not None: 4117 req.meta.CopyFrom(GetRequestMetadata()) 4118 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4119 4120 req.id = (id) 4121 tries = 0 4122 plumbing_response = None 4123 while True: 4124 t = None if deadline is None else deadline - time.time() 4125 try: 4126 plumbing_response = self.stub.Get( 4127 req, 4128 metadata=self.parent.get_metadata( 4129 'PeeringGroupResources.Get', req), 4130 timeout=t) 4131 except Exception as e: 4132 if self.parent.shouldRetry(tries, e, deadline): 4133 tries += 1 4134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4135 continue 4136 raise plumbing.convert_error_to_porcelain(e) from e 4137 break 4138 4139 resp = models.PeeringGroupResourceGetResponse() 4140 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4141 plumbing_response.meta) 4142 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4143 plumbing_response.peering_group_resource) 4144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4145 plumbing_response.rate_limit) 4146 return resp 4147 4148 def list(self, filter, *args, timeout=None): 4149 ''' 4150 List gets a list of peering group resource attachments. 4151 ''' 4152 deadline = None if timeout is None else time.time() + timeout 4153 req = PeeringGroupResourceListRequest() 4154 req.meta.CopyFrom(ListRequestMetadata()) 4155 if self.parent.page_limit > 0: 4156 req.meta.limit = self.parent.page_limit 4157 if self.parent.snapshot_datetime is not None: 4158 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4159 4160 req.filter = plumbing.quote_filter_args(filter, *args) 4161 4162 def generator(svc, req): 4163 tries = 0 4164 while True: 4165 t = None if deadline is None else deadline - time.time() 4166 try: 4167 plumbing_response = svc.stub.List( 4168 req, 4169 metadata=svc.parent.get_metadata( 4170 'PeeringGroupResources.List', req), 4171 timeout=t) 4172 except Exception as e: 4173 if self.parent.shouldRetry(tries, e, deadline): 4174 tries += 1 4175 time.sleep( 4176 self.parent.exponentialBackoff(tries, deadline)) 4177 continue 4178 raise plumbing.convert_error_to_porcelain(e) from e 4179 tries = 0 4180 for plumbing_item in plumbing_response.peering_group_resources: 4181 yield plumbing.convert_peering_group_resource_to_porcelain( 4182 plumbing_item) 4183 if plumbing_response.meta.next_cursor == '': 4184 break 4185 req.meta.cursor = plumbing_response.meta.next_cursor 4186 4187 return generator(self, req) 4188 4189 4190class PeeringGroups: 4191 ''' 4192 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4193 See `strongdm.models.PeeringGroup`. 4194 ''' 4195 def __init__(self, channel, client): 4196 self.parent = client 4197 self.stub = PeeringGroupsStub(channel) 4198 4199 def create(self, peering_group, timeout=None): 4200 ''' 4201 Create registers a new PeeringGroup. 4202 ''' 4203 deadline = None if timeout is None else time.time() + timeout 4204 req = PeeringGroupCreateRequest() 4205 4206 if peering_group is not None: 4207 req.peering_group.CopyFrom( 4208 plumbing.convert_peering_group_to_plumbing(peering_group)) 4209 tries = 0 4210 plumbing_response = None 4211 while True: 4212 t = None if deadline is None else deadline - time.time() 4213 try: 4214 plumbing_response = self.stub.Create( 4215 req, 4216 metadata=self.parent.get_metadata('PeeringGroups.Create', 4217 req), 4218 timeout=t) 4219 except Exception as e: 4220 if self.parent.shouldRetry(tries, e, deadline): 4221 tries += 1 4222 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4223 continue 4224 raise plumbing.convert_error_to_porcelain(e) from e 4225 break 4226 4227 resp = models.PeeringGroupCreateResponse() 4228 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4229 plumbing_response.meta) 4230 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4231 plumbing_response.peering_group) 4232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4233 plumbing_response.rate_limit) 4234 return resp 4235 4236 def delete(self, id, timeout=None): 4237 ''' 4238 Delete removes a PeeringGroup by ID. 4239 ''' 4240 deadline = None if timeout is None else time.time() + timeout 4241 req = PeeringGroupDeleteRequest() 4242 4243 req.id = (id) 4244 tries = 0 4245 plumbing_response = None 4246 while True: 4247 t = None if deadline is None else deadline - time.time() 4248 try: 4249 plumbing_response = self.stub.Delete( 4250 req, 4251 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4252 req), 4253 timeout=t) 4254 except Exception as e: 4255 if self.parent.shouldRetry(tries, e, deadline): 4256 tries += 1 4257 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4258 continue 4259 raise plumbing.convert_error_to_porcelain(e) from e 4260 break 4261 4262 resp = models.PeeringGroupDeleteResponse() 4263 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4264 plumbing_response.meta) 4265 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4266 plumbing_response.rate_limit) 4267 return resp 4268 4269 def get(self, id, timeout=None): 4270 ''' 4271 Get reads one PeeringGroup by ID. It will load all its dependencies. 4272 ''' 4273 deadline = None if timeout is None else time.time() + timeout 4274 req = PeeringGroupGetRequest() 4275 if self.parent.snapshot_datetime is not None: 4276 req.meta.CopyFrom(GetRequestMetadata()) 4277 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4278 4279 req.id = (id) 4280 tries = 0 4281 plumbing_response = None 4282 while True: 4283 t = None if deadline is None else deadline - time.time() 4284 try: 4285 plumbing_response = self.stub.Get( 4286 req, 4287 metadata=self.parent.get_metadata('PeeringGroups.Get', 4288 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.PeeringGroupGetResponse() 4299 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4300 plumbing_response.meta) 4301 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4302 plumbing_response.peering_group) 4303 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4304 plumbing_response.rate_limit) 4305 return resp 4306 4307 def list(self, filter, *args, timeout=None): 4308 ''' 4309 List gets a list of Peering Groups. 4310 ''' 4311 deadline = None if timeout is None else time.time() + timeout 4312 req = PeeringGroupListRequest() 4313 req.meta.CopyFrom(ListRequestMetadata()) 4314 if self.parent.page_limit > 0: 4315 req.meta.limit = self.parent.page_limit 4316 if self.parent.snapshot_datetime is not None: 4317 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4318 4319 req.filter = plumbing.quote_filter_args(filter, *args) 4320 4321 def generator(svc, req): 4322 tries = 0 4323 while True: 4324 t = None if deadline is None else deadline - time.time() 4325 try: 4326 plumbing_response = svc.stub.List( 4327 req, 4328 metadata=svc.parent.get_metadata( 4329 'PeeringGroups.List', req), 4330 timeout=t) 4331 except Exception as e: 4332 if self.parent.shouldRetry(tries, e, deadline): 4333 tries += 1 4334 time.sleep( 4335 self.parent.exponentialBackoff(tries, deadline)) 4336 continue 4337 raise plumbing.convert_error_to_porcelain(e) from e 4338 tries = 0 4339 for plumbing_item in plumbing_response.peering_groups: 4340 yield plumbing.convert_peering_group_to_porcelain( 4341 plumbing_item) 4342 if plumbing_response.meta.next_cursor == '': 4343 break 4344 req.meta.cursor = plumbing_response.meta.next_cursor 4345 4346 return generator(self, req) 4347 4348 4349class Policies: 4350 ''' 4351 Policies are the collection of one or more statements that enforce fine-grained access 4352 control for the users of an organization. 4353 See `strongdm.models.Policy`. 4354 ''' 4355 def __init__(self, channel, client): 4356 self.parent = client 4357 self.stub = PoliciesStub(channel) 4358 4359 def create(self, policy, timeout=None): 4360 ''' 4361 Create creates a new Policy. 4362 ''' 4363 deadline = None if timeout is None else time.time() + timeout 4364 req = PolicyCreateRequest() 4365 4366 if policy is not None: 4367 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4368 tries = 0 4369 plumbing_response = None 4370 while True: 4371 t = None if deadline is None else deadline - time.time() 4372 try: 4373 plumbing_response = self.stub.Create( 4374 req, 4375 metadata=self.parent.get_metadata('Policies.Create', req), 4376 timeout=t) 4377 except Exception as e: 4378 if self.parent.shouldRetry(tries, e, deadline): 4379 tries += 1 4380 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4381 continue 4382 raise plumbing.convert_error_to_porcelain(e) from e 4383 break 4384 4385 resp = models.PolicyCreateResponse() 4386 resp.policy = plumbing.convert_policy_to_porcelain( 4387 plumbing_response.policy) 4388 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4389 plumbing_response.rate_limit) 4390 return resp 4391 4392 def delete(self, id, timeout=None): 4393 ''' 4394 Delete removes a Policy by ID. 4395 ''' 4396 deadline = None if timeout is None else time.time() + timeout 4397 req = PolicyDeleteRequest() 4398 4399 req.id = (id) 4400 tries = 0 4401 plumbing_response = None 4402 while True: 4403 t = None if deadline is None else deadline - time.time() 4404 try: 4405 plumbing_response = self.stub.Delete( 4406 req, 4407 metadata=self.parent.get_metadata('Policies.Delete', req), 4408 timeout=t) 4409 except Exception as e: 4410 if self.parent.shouldRetry(tries, e, deadline): 4411 tries += 1 4412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4413 continue 4414 raise plumbing.convert_error_to_porcelain(e) from e 4415 break 4416 4417 resp = models.PolicyDeleteResponse() 4418 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4419 plumbing_response.rate_limit) 4420 return resp 4421 4422 def update(self, policy, timeout=None): 4423 ''' 4424 Update replaces all the fields of a Policy by ID. 4425 ''' 4426 deadline = None if timeout is None else time.time() + timeout 4427 req = PolicyUpdateRequest() 4428 4429 if policy is not None: 4430 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4431 tries = 0 4432 plumbing_response = None 4433 while True: 4434 t = None if deadline is None else deadline - time.time() 4435 try: 4436 plumbing_response = self.stub.Update( 4437 req, 4438 metadata=self.parent.get_metadata('Policies.Update', req), 4439 timeout=t) 4440 except Exception as e: 4441 if self.parent.shouldRetry(tries, e, deadline): 4442 tries += 1 4443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4444 continue 4445 raise plumbing.convert_error_to_porcelain(e) from e 4446 break 4447 4448 resp = models.PolicyUpdateResponse() 4449 resp.policy = plumbing.convert_policy_to_porcelain( 4450 plumbing_response.policy) 4451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4452 plumbing_response.rate_limit) 4453 return resp 4454 4455 def get(self, id, timeout=None): 4456 ''' 4457 Get reads one Policy by ID. 4458 ''' 4459 deadline = None if timeout is None else time.time() + timeout 4460 req = PolicyGetRequest() 4461 if self.parent.snapshot_datetime is not None: 4462 req.meta.CopyFrom(GetRequestMetadata()) 4463 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4464 4465 req.id = (id) 4466 tries = 0 4467 plumbing_response = None 4468 while True: 4469 t = None if deadline is None else deadline - time.time() 4470 try: 4471 plumbing_response = self.stub.Get( 4472 req, 4473 metadata=self.parent.get_metadata('Policies.Get', req), 4474 timeout=t) 4475 except Exception as e: 4476 if self.parent.shouldRetry(tries, e, deadline): 4477 tries += 1 4478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4479 continue 4480 raise plumbing.convert_error_to_porcelain(e) from e 4481 break 4482 4483 resp = models.PolicyGetResponse() 4484 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4485 plumbing_response.meta) 4486 resp.policy = plumbing.convert_policy_to_porcelain( 4487 plumbing_response.policy) 4488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4489 plumbing_response.rate_limit) 4490 return resp 4491 4492 def list(self, filter, *args, timeout=None): 4493 ''' 4494 List gets a list of Policy matching a given set of criteria 4495 ''' 4496 deadline = None if timeout is None else time.time() + timeout 4497 req = PolicyListRequest() 4498 req.meta.CopyFrom(ListRequestMetadata()) 4499 if self.parent.page_limit > 0: 4500 req.meta.limit = self.parent.page_limit 4501 if self.parent.snapshot_datetime is not None: 4502 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4503 4504 req.filter = plumbing.quote_filter_args(filter, *args) 4505 4506 def generator(svc, req): 4507 tries = 0 4508 while True: 4509 t = None if deadline is None else deadline - time.time() 4510 try: 4511 plumbing_response = svc.stub.List( 4512 req, 4513 metadata=svc.parent.get_metadata('Policies.List', req), 4514 timeout=t) 4515 except Exception as e: 4516 if self.parent.shouldRetry(tries, e, deadline): 4517 tries += 1 4518 time.sleep( 4519 self.parent.exponentialBackoff(tries, deadline)) 4520 continue 4521 raise plumbing.convert_error_to_porcelain(e) from e 4522 tries = 0 4523 for plumbing_item in plumbing_response.policies: 4524 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4525 if plumbing_response.meta.next_cursor == '': 4526 break 4527 req.meta.cursor = plumbing_response.meta.next_cursor 4528 4529 return generator(self, req) 4530 4531 4532class SnapshotPolicies: 4533 ''' 4534 SnapshotPolicies exposes the read only methods of the Policies 4535 service for historical queries. 4536 ''' 4537 def __init__(self, policies): 4538 self.policies = policies 4539 4540 def get(self, id, timeout=None): 4541 ''' 4542 Get reads one Policy by ID. 4543 ''' 4544 return self.policies.get(id, timeout=timeout) 4545 4546 def list(self, filter, *args, timeout=None): 4547 ''' 4548 List gets a list of Policy matching a given set of criteria 4549 ''' 4550 return self.policies.list(filter, *args, timeout=timeout) 4551 4552 4553class PoliciesHistory: 4554 ''' 4555 PoliciesHistory records all changes to the state of a Policy. 4556 See `strongdm.models.PolicyHistory`. 4557 ''' 4558 def __init__(self, channel, client): 4559 self.parent = client 4560 self.stub = PoliciesHistoryStub(channel) 4561 4562 def list(self, filter, *args, timeout=None): 4563 ''' 4564 List gets a list of PolicyHistory records matching a given set of criteria. 4565 ''' 4566 deadline = None if timeout is None else time.time() + timeout 4567 req = PoliciesHistoryListRequest() 4568 req.meta.CopyFrom(ListRequestMetadata()) 4569 if self.parent.page_limit > 0: 4570 req.meta.limit = self.parent.page_limit 4571 if self.parent.snapshot_datetime is not None: 4572 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4573 4574 req.filter = plumbing.quote_filter_args(filter, *args) 4575 4576 def generator(svc, req): 4577 tries = 0 4578 while True: 4579 t = None if deadline is None else deadline - time.time() 4580 try: 4581 plumbing_response = svc.stub.List( 4582 req, 4583 metadata=svc.parent.get_metadata( 4584 'PoliciesHistory.List', req), 4585 timeout=t) 4586 except Exception as e: 4587 if self.parent.shouldRetry(tries, e, deadline): 4588 tries += 1 4589 time.sleep( 4590 self.parent.exponentialBackoff(tries, deadline)) 4591 continue 4592 raise plumbing.convert_error_to_porcelain(e) from e 4593 tries = 0 4594 for plumbing_item in plumbing_response.history: 4595 yield plumbing.convert_policy_history_to_porcelain( 4596 plumbing_item) 4597 if plumbing_response.meta.next_cursor == '': 4598 break 4599 req.meta.cursor = plumbing_response.meta.next_cursor 4600 4601 return generator(self, req) 4602 4603 4604class ProxyClusterKeys: 4605 ''' 4606 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4607 The proxies within a cluster share the same key. One cluster can have 4608 multiple keys in order to facilitate key rotation. 4609 See `strongdm.models.ProxyClusterKey`. 4610 ''' 4611 def __init__(self, channel, client): 4612 self.parent = client 4613 self.stub = ProxyClusterKeysStub(channel) 4614 4615 def create(self, proxy_cluster_key, timeout=None): 4616 ''' 4617 Create registers a new ProxyClusterKey. 4618 ''' 4619 deadline = None if timeout is None else time.time() + timeout 4620 req = ProxyClusterKeyCreateRequest() 4621 4622 if proxy_cluster_key is not None: 4623 req.proxy_cluster_key.CopyFrom( 4624 plumbing.convert_proxy_cluster_key_to_plumbing( 4625 proxy_cluster_key)) 4626 tries = 0 4627 plumbing_response = None 4628 while True: 4629 t = None if deadline is None else deadline - time.time() 4630 try: 4631 plumbing_response = self.stub.Create( 4632 req, 4633 metadata=self.parent.get_metadata( 4634 'ProxyClusterKeys.Create', req), 4635 timeout=t) 4636 except Exception as e: 4637 if self.parent.shouldRetry(tries, e, deadline): 4638 tries += 1 4639 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4640 continue 4641 raise plumbing.convert_error_to_porcelain(e) from e 4642 break 4643 4644 resp = models.ProxyClusterKeyCreateResponse() 4645 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4646 plumbing_response.meta) 4647 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4648 plumbing_response.proxy_cluster_key) 4649 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4650 plumbing_response.rate_limit) 4651 resp.secret_key = (plumbing_response.secret_key) 4652 return resp 4653 4654 def get(self, id, timeout=None): 4655 ''' 4656 Get reads one ProxyClusterKey by ID. 4657 ''' 4658 deadline = None if timeout is None else time.time() + timeout 4659 req = ProxyClusterKeyGetRequest() 4660 if self.parent.snapshot_datetime is not None: 4661 req.meta.CopyFrom(GetRequestMetadata()) 4662 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4663 4664 req.id = (id) 4665 tries = 0 4666 plumbing_response = None 4667 while True: 4668 t = None if deadline is None else deadline - time.time() 4669 try: 4670 plumbing_response = self.stub.Get( 4671 req, 4672 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4673 req), 4674 timeout=t) 4675 except Exception as e: 4676 if self.parent.shouldRetry(tries, e, deadline): 4677 tries += 1 4678 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4679 continue 4680 raise plumbing.convert_error_to_porcelain(e) from e 4681 break 4682 4683 resp = models.ProxyClusterKeyGetResponse() 4684 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4685 plumbing_response.meta) 4686 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4687 plumbing_response.proxy_cluster_key) 4688 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4689 plumbing_response.rate_limit) 4690 return resp 4691 4692 def delete(self, id, timeout=None): 4693 ''' 4694 Delete removes a ProxyClusterKey by ID. 4695 ''' 4696 deadline = None if timeout is None else time.time() + timeout 4697 req = ProxyClusterKeyDeleteRequest() 4698 4699 req.id = (id) 4700 tries = 0 4701 plumbing_response = None 4702 while True: 4703 t = None if deadline is None else deadline - time.time() 4704 try: 4705 plumbing_response = self.stub.Delete( 4706 req, 4707 metadata=self.parent.get_metadata( 4708 'ProxyClusterKeys.Delete', req), 4709 timeout=t) 4710 except Exception as e: 4711 if self.parent.shouldRetry(tries, e, deadline): 4712 tries += 1 4713 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4714 continue 4715 raise plumbing.convert_error_to_porcelain(e) from e 4716 break 4717 4718 resp = models.ProxyClusterKeyDeleteResponse() 4719 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4720 plumbing_response.meta) 4721 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4722 plumbing_response.rate_limit) 4723 return resp 4724 4725 def list(self, filter, *args, timeout=None): 4726 ''' 4727 List gets a list of ProxyClusterKeys matching a given set of criteria. 4728 ''' 4729 deadline = None if timeout is None else time.time() + timeout 4730 req = ProxyClusterKeyListRequest() 4731 req.meta.CopyFrom(ListRequestMetadata()) 4732 if self.parent.page_limit > 0: 4733 req.meta.limit = self.parent.page_limit 4734 if self.parent.snapshot_datetime is not None: 4735 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4736 4737 req.filter = plumbing.quote_filter_args(filter, *args) 4738 4739 def generator(svc, req): 4740 tries = 0 4741 while True: 4742 t = None if deadline is None else deadline - time.time() 4743 try: 4744 plumbing_response = svc.stub.List( 4745 req, 4746 metadata=svc.parent.get_metadata( 4747 'ProxyClusterKeys.List', req), 4748 timeout=t) 4749 except Exception as e: 4750 if self.parent.shouldRetry(tries, e, deadline): 4751 tries += 1 4752 time.sleep( 4753 self.parent.exponentialBackoff(tries, deadline)) 4754 continue 4755 raise plumbing.convert_error_to_porcelain(e) from e 4756 tries = 0 4757 for plumbing_item in plumbing_response.proxy_cluster_keys: 4758 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4759 plumbing_item) 4760 if plumbing_response.meta.next_cursor == '': 4761 break 4762 req.meta.cursor = plumbing_response.meta.next_cursor 4763 4764 return generator(self, req) 4765 4766 4767class SnapshotProxyClusterKeys: 4768 ''' 4769 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4770 service for historical queries. 4771 ''' 4772 def __init__(self, proxy_cluster_keys): 4773 self.proxy_cluster_keys = proxy_cluster_keys 4774 4775 def get(self, id, timeout=None): 4776 ''' 4777 Get reads one ProxyClusterKey by ID. 4778 ''' 4779 return self.proxy_cluster_keys.get(id, timeout=timeout) 4780 4781 def list(self, filter, *args, timeout=None): 4782 ''' 4783 List gets a list of ProxyClusterKeys matching a given set of criteria. 4784 ''' 4785 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 4786 4787 4788class Queries: 4789 ''' 4790 A Query is a record of a single client request to a resource, such as a SQL query. 4791 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4792 The Queries service is read-only. 4793 See `strongdm.models.Query`. 4794 ''' 4795 def __init__(self, channel, client): 4796 self.parent = client 4797 self.stub = QueriesStub(channel) 4798 4799 def list(self, filter, *args, timeout=None): 4800 ''' 4801 List gets a list of Queries matching a given set of criteria. 4802 ''' 4803 deadline = None if timeout is None else time.time() + timeout 4804 req = QueryListRequest() 4805 req.meta.CopyFrom(ListRequestMetadata()) 4806 if self.parent.page_limit > 0: 4807 req.meta.limit = self.parent.page_limit 4808 if self.parent.snapshot_datetime is not None: 4809 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4810 4811 req.filter = plumbing.quote_filter_args(filter, *args) 4812 4813 def generator(svc, req): 4814 tries = 0 4815 while True: 4816 t = None if deadline is None else deadline - time.time() 4817 try: 4818 plumbing_response = svc.stub.List( 4819 req, 4820 metadata=svc.parent.get_metadata('Queries.List', req), 4821 timeout=t) 4822 except Exception as e: 4823 if self.parent.shouldRetry(tries, e, deadline): 4824 tries += 1 4825 time.sleep( 4826 self.parent.exponentialBackoff(tries, deadline)) 4827 continue 4828 raise plumbing.convert_error_to_porcelain(e) from e 4829 tries = 0 4830 for plumbing_item in plumbing_response.queries: 4831 yield plumbing.convert_query_to_porcelain(plumbing_item) 4832 if plumbing_response.meta.next_cursor == '': 4833 break 4834 req.meta.cursor = plumbing_response.meta.next_cursor 4835 4836 return generator(self, req) 4837 4838 4839class RemoteIdentities: 4840 ''' 4841 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4842 See `strongdm.models.RemoteIdentity`. 4843 ''' 4844 def __init__(self, channel, client): 4845 self.parent = client 4846 self.stub = RemoteIdentitiesStub(channel) 4847 4848 def create(self, remote_identity, timeout=None): 4849 ''' 4850 Create registers a new RemoteIdentity. 4851 ''' 4852 deadline = None if timeout is None else time.time() + timeout 4853 req = RemoteIdentityCreateRequest() 4854 4855 if remote_identity is not None: 4856 req.remote_identity.CopyFrom( 4857 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4858 tries = 0 4859 plumbing_response = None 4860 while True: 4861 t = None if deadline is None else deadline - time.time() 4862 try: 4863 plumbing_response = self.stub.Create( 4864 req, 4865 metadata=self.parent.get_metadata( 4866 'RemoteIdentities.Create', req), 4867 timeout=t) 4868 except Exception as e: 4869 if self.parent.shouldRetry(tries, e, deadline): 4870 tries += 1 4871 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4872 continue 4873 raise plumbing.convert_error_to_porcelain(e) from e 4874 break 4875 4876 resp = models.RemoteIdentityCreateResponse() 4877 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4878 plumbing_response.meta) 4879 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4880 plumbing_response.rate_limit) 4881 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4882 plumbing_response.remote_identity) 4883 return resp 4884 4885 def get(self, id, timeout=None): 4886 ''' 4887 Get reads one RemoteIdentity by ID. 4888 ''' 4889 deadline = None if timeout is None else time.time() + timeout 4890 req = RemoteIdentityGetRequest() 4891 if self.parent.snapshot_datetime is not None: 4892 req.meta.CopyFrom(GetRequestMetadata()) 4893 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4894 4895 req.id = (id) 4896 tries = 0 4897 plumbing_response = None 4898 while True: 4899 t = None if deadline is None else deadline - time.time() 4900 try: 4901 plumbing_response = self.stub.Get( 4902 req, 4903 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4904 req), 4905 timeout=t) 4906 except Exception as e: 4907 if self.parent.shouldRetry(tries, e, deadline): 4908 tries += 1 4909 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4910 continue 4911 raise plumbing.convert_error_to_porcelain(e) from e 4912 break 4913 4914 resp = models.RemoteIdentityGetResponse() 4915 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4916 plumbing_response.meta) 4917 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4918 plumbing_response.rate_limit) 4919 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4920 plumbing_response.remote_identity) 4921 return resp 4922 4923 def update(self, remote_identity, timeout=None): 4924 ''' 4925 Update replaces all the fields of a RemoteIdentity by ID. 4926 ''' 4927 deadline = None if timeout is None else time.time() + timeout 4928 req = RemoteIdentityUpdateRequest() 4929 4930 if remote_identity is not None: 4931 req.remote_identity.CopyFrom( 4932 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4933 tries = 0 4934 plumbing_response = None 4935 while True: 4936 t = None if deadline is None else deadline - time.time() 4937 try: 4938 plumbing_response = self.stub.Update( 4939 req, 4940 metadata=self.parent.get_metadata( 4941 'RemoteIdentities.Update', req), 4942 timeout=t) 4943 except Exception as e: 4944 if self.parent.shouldRetry(tries, e, deadline): 4945 tries += 1 4946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4947 continue 4948 raise plumbing.convert_error_to_porcelain(e) from e 4949 break 4950 4951 resp = models.RemoteIdentityUpdateResponse() 4952 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4953 plumbing_response.meta) 4954 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4955 plumbing_response.rate_limit) 4956 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4957 plumbing_response.remote_identity) 4958 return resp 4959 4960 def delete(self, id, timeout=None): 4961 ''' 4962 Delete removes a RemoteIdentity by ID. 4963 ''' 4964 deadline = None if timeout is None else time.time() + timeout 4965 req = RemoteIdentityDeleteRequest() 4966 4967 req.id = (id) 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.Delete( 4974 req, 4975 metadata=self.parent.get_metadata( 4976 'RemoteIdentities.Delete', 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.RemoteIdentityDeleteResponse() 4987 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4988 plumbing_response.meta) 4989 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4990 plumbing_response.rate_limit) 4991 return resp 4992 4993 def list(self, filter, *args, timeout=None): 4994 ''' 4995 List gets a list of RemoteIdentities matching a given set of criteria. 4996 ''' 4997 deadline = None if timeout is None else time.time() + timeout 4998 req = RemoteIdentityListRequest() 4999 req.meta.CopyFrom(ListRequestMetadata()) 5000 if self.parent.page_limit > 0: 5001 req.meta.limit = self.parent.page_limit 5002 if self.parent.snapshot_datetime is not None: 5003 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5004 5005 req.filter = plumbing.quote_filter_args(filter, *args) 5006 5007 def generator(svc, req): 5008 tries = 0 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = svc.stub.List( 5013 req, 5014 metadata=svc.parent.get_metadata( 5015 'RemoteIdentities.List', req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep( 5021 self.parent.exponentialBackoff(tries, deadline)) 5022 continue 5023 raise plumbing.convert_error_to_porcelain(e) from e 5024 tries = 0 5025 for plumbing_item in plumbing_response.remote_identities: 5026 yield plumbing.convert_remote_identity_to_porcelain( 5027 plumbing_item) 5028 if plumbing_response.meta.next_cursor == '': 5029 break 5030 req.meta.cursor = plumbing_response.meta.next_cursor 5031 5032 return generator(self, req) 5033 5034 5035class SnapshotRemoteIdentities: 5036 ''' 5037 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5038 service for historical queries. 5039 ''' 5040 def __init__(self, remote_identities): 5041 self.remote_identities = remote_identities 5042 5043 def get(self, id, timeout=None): 5044 ''' 5045 Get reads one RemoteIdentity by ID. 5046 ''' 5047 return self.remote_identities.get(id, timeout=timeout) 5048 5049 def list(self, filter, *args, timeout=None): 5050 ''' 5051 List gets a list of RemoteIdentities matching a given set of criteria. 5052 ''' 5053 return self.remote_identities.list(filter, *args, timeout=timeout) 5054 5055 5056class RemoteIdentitiesHistory: 5057 ''' 5058 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5059 See `strongdm.models.RemoteIdentityHistory`. 5060 ''' 5061 def __init__(self, channel, client): 5062 self.parent = client 5063 self.stub = RemoteIdentitiesHistoryStub(channel) 5064 5065 def list(self, filter, *args, timeout=None): 5066 ''' 5067 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5068 ''' 5069 deadline = None if timeout is None else time.time() + timeout 5070 req = RemoteIdentityHistoryListRequest() 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 'RemoteIdentitiesHistory.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.history: 5098 yield plumbing.convert_remote_identity_history_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 RemoteIdentityGroups: 5108 ''' 5109 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5110 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5111 See `strongdm.models.RemoteIdentityGroup`. 5112 ''' 5113 def __init__(self, channel, client): 5114 self.parent = client 5115 self.stub = RemoteIdentityGroupsStub(channel) 5116 5117 def get(self, id, timeout=None): 5118 ''' 5119 Get reads one RemoteIdentityGroup by ID. 5120 ''' 5121 deadline = None if timeout is None else time.time() + timeout 5122 req = RemoteIdentityGroupGetRequest() 5123 if self.parent.snapshot_datetime is not None: 5124 req.meta.CopyFrom(GetRequestMetadata()) 5125 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5126 5127 req.id = (id) 5128 tries = 0 5129 plumbing_response = None 5130 while True: 5131 t = None if deadline is None else deadline - time.time() 5132 try: 5133 plumbing_response = self.stub.Get( 5134 req, 5135 metadata=self.parent.get_metadata( 5136 'RemoteIdentityGroups.Get', req), 5137 timeout=t) 5138 except Exception as e: 5139 if self.parent.shouldRetry(tries, e, deadline): 5140 tries += 1 5141 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5142 continue 5143 raise plumbing.convert_error_to_porcelain(e) from e 5144 break 5145 5146 resp = models.RemoteIdentityGroupGetResponse() 5147 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5148 plumbing_response.meta) 5149 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5150 plumbing_response.rate_limit) 5151 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5152 plumbing_response.remote_identity_group) 5153 return resp 5154 5155 def list(self, filter, *args, timeout=None): 5156 ''' 5157 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5158 ''' 5159 deadline = None if timeout is None else time.time() + timeout 5160 req = RemoteIdentityGroupListRequest() 5161 req.meta.CopyFrom(ListRequestMetadata()) 5162 if self.parent.page_limit > 0: 5163 req.meta.limit = self.parent.page_limit 5164 if self.parent.snapshot_datetime is not None: 5165 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5166 5167 req.filter = plumbing.quote_filter_args(filter, *args) 5168 5169 def generator(svc, req): 5170 tries = 0 5171 while True: 5172 t = None if deadline is None else deadline - time.time() 5173 try: 5174 plumbing_response = svc.stub.List( 5175 req, 5176 metadata=svc.parent.get_metadata( 5177 'RemoteIdentityGroups.List', req), 5178 timeout=t) 5179 except Exception as e: 5180 if self.parent.shouldRetry(tries, e, deadline): 5181 tries += 1 5182 time.sleep( 5183 self.parent.exponentialBackoff(tries, deadline)) 5184 continue 5185 raise plumbing.convert_error_to_porcelain(e) from e 5186 tries = 0 5187 for plumbing_item in plumbing_response.remote_identity_groups: 5188 yield plumbing.convert_remote_identity_group_to_porcelain( 5189 plumbing_item) 5190 if plumbing_response.meta.next_cursor == '': 5191 break 5192 req.meta.cursor = plumbing_response.meta.next_cursor 5193 5194 return generator(self, req) 5195 5196 5197class SnapshotRemoteIdentityGroups: 5198 ''' 5199 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5200 service for historical queries. 5201 ''' 5202 def __init__(self, remote_identity_groups): 5203 self.remote_identity_groups = remote_identity_groups 5204 5205 def get(self, id, timeout=None): 5206 ''' 5207 Get reads one RemoteIdentityGroup by ID. 5208 ''' 5209 return self.remote_identity_groups.get(id, timeout=timeout) 5210 5211 def list(self, filter, *args, timeout=None): 5212 ''' 5213 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5214 ''' 5215 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 5216 5217 5218class RemoteIdentityGroupsHistory: 5219 ''' 5220 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 5221 See `strongdm.models.RemoteIdentityGroupHistory`. 5222 ''' 5223 def __init__(self, channel, client): 5224 self.parent = client 5225 self.stub = RemoteIdentityGroupsHistoryStub(channel) 5226 5227 def list(self, filter, *args, timeout=None): 5228 ''' 5229 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5230 ''' 5231 deadline = None if timeout is None else time.time() + timeout 5232 req = RemoteIdentityGroupHistoryListRequest() 5233 req.meta.CopyFrom(ListRequestMetadata()) 5234 if self.parent.page_limit > 0: 5235 req.meta.limit = self.parent.page_limit 5236 if self.parent.snapshot_datetime is not None: 5237 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5238 5239 req.filter = plumbing.quote_filter_args(filter, *args) 5240 5241 def generator(svc, req): 5242 tries = 0 5243 while True: 5244 t = None if deadline is None else deadline - time.time() 5245 try: 5246 plumbing_response = svc.stub.List( 5247 req, 5248 metadata=svc.parent.get_metadata( 5249 'RemoteIdentityGroupsHistory.List', req), 5250 timeout=t) 5251 except Exception as e: 5252 if self.parent.shouldRetry(tries, e, deadline): 5253 tries += 1 5254 time.sleep( 5255 self.parent.exponentialBackoff(tries, deadline)) 5256 continue 5257 raise plumbing.convert_error_to_porcelain(e) from e 5258 tries = 0 5259 for plumbing_item in plumbing_response.history: 5260 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5261 plumbing_item) 5262 if plumbing_response.meta.next_cursor == '': 5263 break 5264 req.meta.cursor = plumbing_response.meta.next_cursor 5265 5266 return generator(self, req) 5267 5268 5269class Replays: 5270 ''' 5271 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5272 (otherwise referred to as a query). The Replays service is read-only. 5273 See `strongdm.models.ReplayChunk`. 5274 ''' 5275 def __init__(self, channel, client): 5276 self.parent = client 5277 self.stub = ReplaysStub(channel) 5278 5279 def list(self, filter, *args, timeout=None): 5280 ''' 5281 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5282 ''' 5283 deadline = None if timeout is None else time.time() + timeout 5284 req = ReplayListRequest() 5285 req.meta.CopyFrom(ListRequestMetadata()) 5286 if self.parent.page_limit > 0: 5287 req.meta.limit = self.parent.page_limit 5288 if self.parent.snapshot_datetime is not None: 5289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5290 5291 req.filter = plumbing.quote_filter_args(filter, *args) 5292 5293 def generator(svc, req): 5294 tries = 0 5295 while True: 5296 t = None if deadline is None else deadline - time.time() 5297 try: 5298 plumbing_response = svc.stub.List( 5299 req, 5300 metadata=svc.parent.get_metadata('Replays.List', req), 5301 timeout=t) 5302 except Exception as e: 5303 if self.parent.shouldRetry(tries, e, deadline): 5304 tries += 1 5305 time.sleep( 5306 self.parent.exponentialBackoff(tries, deadline)) 5307 continue 5308 raise plumbing.convert_error_to_porcelain(e) from e 5309 tries = 0 5310 for plumbing_item in plumbing_response.chunks: 5311 yield plumbing.convert_replay_chunk_to_porcelain( 5312 plumbing_item) 5313 if plumbing_response.meta.next_cursor == '': 5314 break 5315 req.meta.cursor = plumbing_response.meta.next_cursor 5316 5317 return generator(self, req) 5318 5319 5320class Resources: 5321 ''' 5322 Resources are databases, servers, clusters, websites, or clouds that strongDM 5323 delegates access to. 5324 See: 5325 `strongdm.models.Aerospike` 5326 `strongdm.models.AKS` 5327 `strongdm.models.AKSBasicAuth` 5328 `strongdm.models.AKSServiceAccount` 5329 `strongdm.models.AKSServiceAccountUserImpersonation` 5330 `strongdm.models.AKSUserImpersonation` 5331 `strongdm.models.AmazonEKS` 5332 `strongdm.models.AmazonEKSInstanceProfile` 5333 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5334 `strongdm.models.AmazonEKSUserImpersonation` 5335 `strongdm.models.AmazonES` 5336 `strongdm.models.AmazonESIAM` 5337 `strongdm.models.AmazonMQAMQP091` 5338 `strongdm.models.AMQP` 5339 `strongdm.models.Athena` 5340 `strongdm.models.AthenaIAM` 5341 `strongdm.models.AuroraMysql` 5342 `strongdm.models.AuroraMysqlIAM` 5343 `strongdm.models.AuroraPostgres` 5344 `strongdm.models.AuroraPostgresIAM` 5345 `strongdm.models.AWS` 5346 `strongdm.models.AWSConsole` 5347 `strongdm.models.AWSConsoleStaticKeyPair` 5348 `strongdm.models.AWSInstanceProfile` 5349 `strongdm.models.Azure` 5350 `strongdm.models.AzureCertificate` 5351 `strongdm.models.AzureConsole` 5352 `strongdm.models.AzureMysql` 5353 `strongdm.models.AzureMysqlManagedIdentity` 5354 `strongdm.models.AzurePostgres` 5355 `strongdm.models.AzurePostgresManagedIdentity` 5356 `strongdm.models.BigQuery` 5357 `strongdm.models.Cassandra` 5358 `strongdm.models.Citus` 5359 `strongdm.models.ClickHouseHTTP` 5360 `strongdm.models.ClickHouseMySQL` 5361 `strongdm.models.ClickHouseTCP` 5362 `strongdm.models.Clustrix` 5363 `strongdm.models.Cockroach` 5364 `strongdm.models.CouchbaseDatabase` 5365 `strongdm.models.CouchbaseWebUI` 5366 `strongdm.models.DB2I` 5367 `strongdm.models.DB2LUW` 5368 `strongdm.models.DocumentDBHost` 5369 `strongdm.models.DocumentDBHostIAM` 5370 `strongdm.models.DocumentDBReplicaSet` 5371 `strongdm.models.DocumentDBReplicaSetIAM` 5372 `strongdm.models.Druid` 5373 `strongdm.models.DynamoDB` 5374 `strongdm.models.DynamoDBIAM` 5375 `strongdm.models.Elastic` 5376 `strongdm.models.ElasticacheRedis` 5377 `strongdm.models.GCP` 5378 `strongdm.models.GCPConsole` 5379 `strongdm.models.GCPWIF` 5380 `strongdm.models.GoogleGKE` 5381 `strongdm.models.GoogleGKEUserImpersonation` 5382 `strongdm.models.Greenplum` 5383 `strongdm.models.HTTPAuth` 5384 `strongdm.models.HTTPBasicAuth` 5385 `strongdm.models.HTTPNoAuth` 5386 `strongdm.models.Kubernetes` 5387 `strongdm.models.KubernetesBasicAuth` 5388 `strongdm.models.KubernetesPodIdentity` 5389 `strongdm.models.KubernetesServiceAccount` 5390 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5391 `strongdm.models.KubernetesUserImpersonation` 5392 `strongdm.models.Maria` 5393 `strongdm.models.Memcached` 5394 `strongdm.models.Memsql` 5395 `strongdm.models.MongoHost` 5396 `strongdm.models.MongoLegacyHost` 5397 `strongdm.models.MongoLegacyReplicaset` 5398 `strongdm.models.MongoReplicaSet` 5399 `strongdm.models.MongoShardedCluster` 5400 `strongdm.models.MTLSMysql` 5401 `strongdm.models.MTLSPostgres` 5402 `strongdm.models.Mysql` 5403 `strongdm.models.Neptune` 5404 `strongdm.models.NeptuneIAM` 5405 `strongdm.models.Oracle` 5406 `strongdm.models.OracleNNE` 5407 `strongdm.models.Postgres` 5408 `strongdm.models.Presto` 5409 `strongdm.models.RabbitMQAMQP091` 5410 `strongdm.models.RawTCP` 5411 `strongdm.models.RDP` 5412 `strongdm.models.RDPCert` 5413 `strongdm.models.RDSPostgresIAM` 5414 `strongdm.models.Redis` 5415 `strongdm.models.RedisCluster` 5416 `strongdm.models.Redshift` 5417 `strongdm.models.RedshiftIAM` 5418 `strongdm.models.RedshiftServerlessIAM` 5419 `strongdm.models.SingleStore` 5420 `strongdm.models.Snowflake` 5421 `strongdm.models.Snowsight` 5422 `strongdm.models.SQLServer` 5423 `strongdm.models.SQLServerAzureAD` 5424 `strongdm.models.SQLServerKerberosAD` 5425 `strongdm.models.SSH` 5426 `strongdm.models.SSHCert` 5427 `strongdm.models.SSHCustomerKey` 5428 `strongdm.models.SSHPassword` 5429 `strongdm.models.Sybase` 5430 `strongdm.models.SybaseIQ` 5431 `strongdm.models.Teradata` 5432 `strongdm.models.Trino` 5433 `strongdm.models.Vertica` 5434 ''' 5435 def __init__(self, channel, client): 5436 self.parent = client 5437 self.stub = ResourcesStub(channel) 5438 5439 def enumerate_tags(self, filter, *args, timeout=None): 5440 ''' 5441 EnumerateTags gets a list of the filter matching tags. 5442 ''' 5443 deadline = None if timeout is None else time.time() + timeout 5444 req = EnumerateTagsRequest() 5445 req.meta.CopyFrom(ListRequestMetadata()) 5446 if self.parent.page_limit > 0: 5447 req.meta.limit = self.parent.page_limit 5448 if self.parent.snapshot_datetime is not None: 5449 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5450 5451 req.filter = plumbing.quote_filter_args(filter, *args) 5452 5453 def generator(svc, req): 5454 tries = 0 5455 while True: 5456 t = None if deadline is None else deadline - time.time() 5457 try: 5458 plumbing_response = svc.stub.EnumerateTags( 5459 req, 5460 metadata=svc.parent.get_metadata( 5461 'Resources.EnumerateTags', req), 5462 timeout=t) 5463 except Exception as e: 5464 if self.parent.shouldRetry(tries, e, deadline): 5465 tries += 1 5466 time.sleep( 5467 self.parent.exponentialBackoff(tries, deadline)) 5468 continue 5469 raise plumbing.convert_error_to_porcelain(e) from e 5470 tries = 0 5471 for plumbing_item in plumbing_response.matches: 5472 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5473 if plumbing_response.meta.next_cursor == '': 5474 break 5475 req.meta.cursor = plumbing_response.meta.next_cursor 5476 5477 return generator(self, req) 5478 5479 def create(self, resource, timeout=None): 5480 ''' 5481 Create registers a new Resource. 5482 ''' 5483 deadline = None if timeout is None else time.time() + timeout 5484 req = ResourceCreateRequest() 5485 5486 if resource is not None: 5487 req.resource.CopyFrom( 5488 plumbing.convert_resource_to_plumbing(resource)) 5489 tries = 0 5490 plumbing_response = None 5491 while True: 5492 t = None if deadline is None else deadline - time.time() 5493 try: 5494 plumbing_response = self.stub.Create( 5495 req, 5496 metadata=self.parent.get_metadata('Resources.Create', req), 5497 timeout=t) 5498 except Exception as e: 5499 if self.parent.shouldRetry(tries, e, deadline): 5500 tries += 1 5501 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5502 continue 5503 raise plumbing.convert_error_to_porcelain(e) from e 5504 break 5505 5506 resp = models.ResourceCreateResponse() 5507 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5508 plumbing_response.meta) 5509 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5510 plumbing_response.rate_limit) 5511 resp.resource = plumbing.convert_resource_to_porcelain( 5512 plumbing_response.resource) 5513 return resp 5514 5515 def get(self, id, timeout=None): 5516 ''' 5517 Get reads one Resource by ID. 5518 ''' 5519 deadline = None if timeout is None else time.time() + timeout 5520 req = ResourceGetRequest() 5521 if self.parent.snapshot_datetime is not None: 5522 req.meta.CopyFrom(GetRequestMetadata()) 5523 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5524 5525 req.id = (id) 5526 tries = 0 5527 plumbing_response = None 5528 while True: 5529 t = None if deadline is None else deadline - time.time() 5530 try: 5531 plumbing_response = self.stub.Get( 5532 req, 5533 metadata=self.parent.get_metadata('Resources.Get', req), 5534 timeout=t) 5535 except Exception as e: 5536 if self.parent.shouldRetry(tries, e, deadline): 5537 tries += 1 5538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5539 continue 5540 raise plumbing.convert_error_to_porcelain(e) from e 5541 break 5542 5543 resp = models.ResourceGetResponse() 5544 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5545 plumbing_response.meta) 5546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5547 plumbing_response.rate_limit) 5548 resp.resource = plumbing.convert_resource_to_porcelain( 5549 plumbing_response.resource) 5550 return resp 5551 5552 def update(self, resource, timeout=None): 5553 ''' 5554 Update replaces all the fields of a Resource by ID. 5555 ''' 5556 deadline = None if timeout is None else time.time() + timeout 5557 req = ResourceUpdateRequest() 5558 5559 if resource is not None: 5560 req.resource.CopyFrom( 5561 plumbing.convert_resource_to_plumbing(resource)) 5562 tries = 0 5563 plumbing_response = None 5564 while True: 5565 t = None if deadline is None else deadline - time.time() 5566 try: 5567 plumbing_response = self.stub.Update( 5568 req, 5569 metadata=self.parent.get_metadata('Resources.Update', req), 5570 timeout=t) 5571 except Exception as e: 5572 if self.parent.shouldRetry(tries, e, deadline): 5573 tries += 1 5574 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5575 continue 5576 raise plumbing.convert_error_to_porcelain(e) from e 5577 break 5578 5579 resp = models.ResourceUpdateResponse() 5580 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5581 plumbing_response.meta) 5582 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5583 plumbing_response.rate_limit) 5584 resp.resource = plumbing.convert_resource_to_porcelain( 5585 plumbing_response.resource) 5586 return resp 5587 5588 def delete(self, id, timeout=None): 5589 ''' 5590 Delete removes a Resource by ID. 5591 ''' 5592 deadline = None if timeout is None else time.time() + timeout 5593 req = ResourceDeleteRequest() 5594 5595 req.id = (id) 5596 tries = 0 5597 plumbing_response = None 5598 while True: 5599 t = None if deadline is None else deadline - time.time() 5600 try: 5601 plumbing_response = self.stub.Delete( 5602 req, 5603 metadata=self.parent.get_metadata('Resources.Delete', req), 5604 timeout=t) 5605 except Exception as e: 5606 if self.parent.shouldRetry(tries, e, deadline): 5607 tries += 1 5608 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5609 continue 5610 raise plumbing.convert_error_to_porcelain(e) from e 5611 break 5612 5613 resp = models.ResourceDeleteResponse() 5614 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5615 plumbing_response.meta) 5616 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5617 plumbing_response.rate_limit) 5618 return resp 5619 5620 def list(self, filter, *args, timeout=None): 5621 ''' 5622 List gets a list of Resources matching a given set of criteria. 5623 ''' 5624 deadline = None if timeout is None else time.time() + timeout 5625 req = ResourceListRequest() 5626 req.meta.CopyFrom(ListRequestMetadata()) 5627 if self.parent.page_limit > 0: 5628 req.meta.limit = self.parent.page_limit 5629 if self.parent.snapshot_datetime is not None: 5630 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5631 5632 req.filter = plumbing.quote_filter_args(filter, *args) 5633 5634 def generator(svc, req): 5635 tries = 0 5636 while True: 5637 t = None if deadline is None else deadline - time.time() 5638 try: 5639 plumbing_response = svc.stub.List( 5640 req, 5641 metadata=svc.parent.get_metadata( 5642 'Resources.List', req), 5643 timeout=t) 5644 except Exception as e: 5645 if self.parent.shouldRetry(tries, e, deadline): 5646 tries += 1 5647 time.sleep( 5648 self.parent.exponentialBackoff(tries, deadline)) 5649 continue 5650 raise plumbing.convert_error_to_porcelain(e) from e 5651 tries = 0 5652 for plumbing_item in plumbing_response.resources: 5653 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5654 if plumbing_response.meta.next_cursor == '': 5655 break 5656 req.meta.cursor = plumbing_response.meta.next_cursor 5657 5658 return generator(self, req) 5659 5660 def healthcheck(self, id, timeout=None): 5661 ''' 5662 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5663 large network of Nodes. The call will return immediately, and the updated health of the 5664 Resource can be retrieved via Get or List. 5665 ''' 5666 deadline = None if timeout is None else time.time() + timeout 5667 req = ResourceHealthcheckRequest() 5668 5669 req.id = (id) 5670 tries = 0 5671 plumbing_response = None 5672 while True: 5673 t = None if deadline is None else deadline - time.time() 5674 try: 5675 plumbing_response = self.stub.Healthcheck( 5676 req, 5677 metadata=self.parent.get_metadata('Resources.Healthcheck', 5678 req), 5679 timeout=t) 5680 except Exception as e: 5681 if self.parent.shouldRetry(tries, e, deadline): 5682 tries += 1 5683 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5684 continue 5685 raise plumbing.convert_error_to_porcelain(e) from e 5686 break 5687 5688 resp = models.ResourceHealthcheckResponse() 5689 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5690 plumbing_response.meta) 5691 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5692 plumbing_response.rate_limit) 5693 return resp 5694 5695 5696class SnapshotResources: 5697 ''' 5698 SnapshotResources exposes the read only methods of the Resources 5699 service for historical queries. 5700 ''' 5701 def __init__(self, resources): 5702 self.resources = resources 5703 5704 def get(self, id, timeout=None): 5705 ''' 5706 Get reads one Resource by ID. 5707 ''' 5708 return self.resources.get(id, timeout=timeout) 5709 5710 def list(self, filter, *args, timeout=None): 5711 ''' 5712 List gets a list of Resources matching a given set of criteria. 5713 ''' 5714 return self.resources.list(filter, *args, timeout=timeout) 5715 5716 5717class ResourcesHistory: 5718 ''' 5719 ResourcesHistory records all changes to the state of a Resource. 5720 See `strongdm.models.ResourceHistory`. 5721 ''' 5722 def __init__(self, channel, client): 5723 self.parent = client 5724 self.stub = ResourcesHistoryStub(channel) 5725 5726 def list(self, filter, *args, timeout=None): 5727 ''' 5728 List gets a list of ResourceHistory records matching a given set of criteria. 5729 ''' 5730 deadline = None if timeout is None else time.time() + timeout 5731 req = ResourceHistoryListRequest() 5732 req.meta.CopyFrom(ListRequestMetadata()) 5733 if self.parent.page_limit > 0: 5734 req.meta.limit = self.parent.page_limit 5735 if self.parent.snapshot_datetime is not None: 5736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5737 5738 req.filter = plumbing.quote_filter_args(filter, *args) 5739 5740 def generator(svc, req): 5741 tries = 0 5742 while True: 5743 t = None if deadline is None else deadline - time.time() 5744 try: 5745 plumbing_response = svc.stub.List( 5746 req, 5747 metadata=svc.parent.get_metadata( 5748 'ResourcesHistory.List', req), 5749 timeout=t) 5750 except Exception as e: 5751 if self.parent.shouldRetry(tries, e, deadline): 5752 tries += 1 5753 time.sleep( 5754 self.parent.exponentialBackoff(tries, deadline)) 5755 continue 5756 raise plumbing.convert_error_to_porcelain(e) from e 5757 tries = 0 5758 for plumbing_item in plumbing_response.history: 5759 yield plumbing.convert_resource_history_to_porcelain( 5760 plumbing_item) 5761 if plumbing_response.meta.next_cursor == '': 5762 break 5763 req.meta.cursor = plumbing_response.meta.next_cursor 5764 5765 return generator(self, req) 5766 5767 5768class RoleResources: 5769 ''' 5770 RoleResources enumerates the resources to which roles have access. 5771 The RoleResources service is read-only. 5772 See `strongdm.models.RoleResource`. 5773 ''' 5774 def __init__(self, channel, client): 5775 self.parent = client 5776 self.stub = RoleResourcesStub(channel) 5777 5778 def list(self, filter, *args, timeout=None): 5779 ''' 5780 List gets a list of RoleResource records matching a given set of criteria. 5781 ''' 5782 deadline = None if timeout is None else time.time() + timeout 5783 req = RoleResourceListRequest() 5784 req.meta.CopyFrom(ListRequestMetadata()) 5785 if self.parent.page_limit > 0: 5786 req.meta.limit = self.parent.page_limit 5787 if self.parent.snapshot_datetime is not None: 5788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5789 5790 req.filter = plumbing.quote_filter_args(filter, *args) 5791 5792 def generator(svc, req): 5793 tries = 0 5794 while True: 5795 t = None if deadline is None else deadline - time.time() 5796 try: 5797 plumbing_response = svc.stub.List( 5798 req, 5799 metadata=svc.parent.get_metadata( 5800 'RoleResources.List', req), 5801 timeout=t) 5802 except Exception as e: 5803 if self.parent.shouldRetry(tries, e, deadline): 5804 tries += 1 5805 time.sleep( 5806 self.parent.exponentialBackoff(tries, deadline)) 5807 continue 5808 raise plumbing.convert_error_to_porcelain(e) from e 5809 tries = 0 5810 for plumbing_item in plumbing_response.role_resources: 5811 yield plumbing.convert_role_resource_to_porcelain( 5812 plumbing_item) 5813 if plumbing_response.meta.next_cursor == '': 5814 break 5815 req.meta.cursor = plumbing_response.meta.next_cursor 5816 5817 return generator(self, req) 5818 5819 5820class SnapshotRoleResources: 5821 ''' 5822 SnapshotRoleResources exposes the read only methods of the RoleResources 5823 service for historical queries. 5824 ''' 5825 def __init__(self, role_resources): 5826 self.role_resources = role_resources 5827 5828 def list(self, filter, *args, timeout=None): 5829 ''' 5830 List gets a list of RoleResource records matching a given set of criteria. 5831 ''' 5832 return self.role_resources.list(filter, *args, timeout=timeout) 5833 5834 5835class RoleResourcesHistory: 5836 ''' 5837 RoleResourcesHistory records all changes to the state of a RoleResource. 5838 See `strongdm.models.RoleResourceHistory`. 5839 ''' 5840 def __init__(self, channel, client): 5841 self.parent = client 5842 self.stub = RoleResourcesHistoryStub(channel) 5843 5844 def list(self, filter, *args, timeout=None): 5845 ''' 5846 List gets a list of RoleResourceHistory records matching a given set of criteria. 5847 ''' 5848 deadline = None if timeout is None else time.time() + timeout 5849 req = RoleResourceHistoryListRequest() 5850 req.meta.CopyFrom(ListRequestMetadata()) 5851 if self.parent.page_limit > 0: 5852 req.meta.limit = self.parent.page_limit 5853 if self.parent.snapshot_datetime is not None: 5854 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5855 5856 req.filter = plumbing.quote_filter_args(filter, *args) 5857 5858 def generator(svc, req): 5859 tries = 0 5860 while True: 5861 t = None if deadline is None else deadline - time.time() 5862 try: 5863 plumbing_response = svc.stub.List( 5864 req, 5865 metadata=svc.parent.get_metadata( 5866 'RoleResourcesHistory.List', req), 5867 timeout=t) 5868 except Exception as e: 5869 if self.parent.shouldRetry(tries, e, deadline): 5870 tries += 1 5871 time.sleep( 5872 self.parent.exponentialBackoff(tries, deadline)) 5873 continue 5874 raise plumbing.convert_error_to_porcelain(e) from e 5875 tries = 0 5876 for plumbing_item in plumbing_response.history: 5877 yield plumbing.convert_role_resource_history_to_porcelain( 5878 plumbing_item) 5879 if plumbing_response.meta.next_cursor == '': 5880 break 5881 req.meta.cursor = plumbing_response.meta.next_cursor 5882 5883 return generator(self, req) 5884 5885 5886class RolesHistory: 5887 ''' 5888 RolesHistory records all changes to the state of a Role. 5889 See `strongdm.models.RoleHistory`. 5890 ''' 5891 def __init__(self, channel, client): 5892 self.parent = client 5893 self.stub = RolesHistoryStub(channel) 5894 5895 def list(self, filter, *args, timeout=None): 5896 ''' 5897 List gets a list of RoleHistory records matching a given set of criteria. 5898 ''' 5899 deadline = None if timeout is None else time.time() + timeout 5900 req = RoleHistoryListRequest() 5901 req.meta.CopyFrom(ListRequestMetadata()) 5902 if self.parent.page_limit > 0: 5903 req.meta.limit = self.parent.page_limit 5904 if self.parent.snapshot_datetime is not None: 5905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5906 5907 req.filter = plumbing.quote_filter_args(filter, *args) 5908 5909 def generator(svc, req): 5910 tries = 0 5911 while True: 5912 t = None if deadline is None else deadline - time.time() 5913 try: 5914 plumbing_response = svc.stub.List( 5915 req, 5916 metadata=svc.parent.get_metadata( 5917 'RolesHistory.List', req), 5918 timeout=t) 5919 except Exception as e: 5920 if self.parent.shouldRetry(tries, e, deadline): 5921 tries += 1 5922 time.sleep( 5923 self.parent.exponentialBackoff(tries, deadline)) 5924 continue 5925 raise plumbing.convert_error_to_porcelain(e) from e 5926 tries = 0 5927 for plumbing_item in plumbing_response.history: 5928 yield plumbing.convert_role_history_to_porcelain( 5929 plumbing_item) 5930 if plumbing_response.meta.next_cursor == '': 5931 break 5932 req.meta.cursor = plumbing_response.meta.next_cursor 5933 5934 return generator(self, req) 5935 5936 5937class SecretStores: 5938 ''' 5939 SecretStores are servers where resource secrets (passwords, keys) are stored. 5940 See: 5941 `strongdm.models.ActiveDirectoryStore` 5942 `strongdm.models.AWSStore` 5943 `strongdm.models.AWSCertX509Store` 5944 `strongdm.models.AzureStore` 5945 `strongdm.models.CyberarkConjurStore` 5946 `strongdm.models.CyberarkPAMStore` 5947 `strongdm.models.CyberarkPAMExperimentalStore` 5948 `strongdm.models.DelineaStore` 5949 `strongdm.models.GCPStore` 5950 `strongdm.models.GCPCertX509Store` 5951 `strongdm.models.KeyfactorSSHStore` 5952 `strongdm.models.KeyfactorX509Store` 5953 `strongdm.models.VaultAppRoleStore` 5954 `strongdm.models.VaultAppRoleCertSSHStore` 5955 `strongdm.models.VaultAppRoleCertX509Store` 5956 `strongdm.models.VaultAWSEC2Store` 5957 `strongdm.models.VaultAWSIAMStore` 5958 `strongdm.models.VaultTLSStore` 5959 `strongdm.models.VaultTLSCertSSHStore` 5960 `strongdm.models.VaultTLSCertX509Store` 5961 `strongdm.models.VaultTokenStore` 5962 `strongdm.models.VaultTokenCertSSHStore` 5963 `strongdm.models.VaultTokenCertX509Store` 5964 ''' 5965 def __init__(self, channel, client): 5966 self.parent = client 5967 self.stub = SecretStoresStub(channel) 5968 5969 def create(self, secret_store, timeout=None): 5970 deadline = None if timeout is None else time.time() + timeout 5971 req = SecretStoreCreateRequest() 5972 5973 if secret_store is not None: 5974 req.secret_store.CopyFrom( 5975 plumbing.convert_secret_store_to_plumbing(secret_store)) 5976 tries = 0 5977 plumbing_response = None 5978 while True: 5979 t = None if deadline is None else deadline - time.time() 5980 try: 5981 plumbing_response = self.stub.Create( 5982 req, 5983 metadata=self.parent.get_metadata('SecretStores.Create', 5984 req), 5985 timeout=t) 5986 except Exception as e: 5987 if self.parent.shouldRetry(tries, e, deadline): 5988 tries += 1 5989 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5990 continue 5991 raise plumbing.convert_error_to_porcelain(e) from e 5992 break 5993 5994 resp = models.SecretStoreCreateResponse() 5995 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5996 plumbing_response.meta) 5997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5998 plumbing_response.rate_limit) 5999 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6000 plumbing_response.secret_store) 6001 return resp 6002 6003 def get(self, id, timeout=None): 6004 ''' 6005 Get reads one SecretStore by ID. 6006 ''' 6007 deadline = None if timeout is None else time.time() + timeout 6008 req = SecretStoreGetRequest() 6009 if self.parent.snapshot_datetime is not None: 6010 req.meta.CopyFrom(GetRequestMetadata()) 6011 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6012 6013 req.id = (id) 6014 tries = 0 6015 plumbing_response = None 6016 while True: 6017 t = None if deadline is None else deadline - time.time() 6018 try: 6019 plumbing_response = self.stub.Get( 6020 req, 6021 metadata=self.parent.get_metadata('SecretStores.Get', req), 6022 timeout=t) 6023 except Exception as e: 6024 if self.parent.shouldRetry(tries, e, deadline): 6025 tries += 1 6026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6027 continue 6028 raise plumbing.convert_error_to_porcelain(e) from e 6029 break 6030 6031 resp = models.SecretStoreGetResponse() 6032 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6033 plumbing_response.meta) 6034 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6035 plumbing_response.rate_limit) 6036 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6037 plumbing_response.secret_store) 6038 return resp 6039 6040 def update(self, secret_store, timeout=None): 6041 ''' 6042 Update replaces all the fields of a SecretStore by ID. 6043 ''' 6044 deadline = None if timeout is None else time.time() + timeout 6045 req = SecretStoreUpdateRequest() 6046 6047 if secret_store is not None: 6048 req.secret_store.CopyFrom( 6049 plumbing.convert_secret_store_to_plumbing(secret_store)) 6050 tries = 0 6051 plumbing_response = None 6052 while True: 6053 t = None if deadline is None else deadline - time.time() 6054 try: 6055 plumbing_response = self.stub.Update( 6056 req, 6057 metadata=self.parent.get_metadata('SecretStores.Update', 6058 req), 6059 timeout=t) 6060 except Exception as e: 6061 if self.parent.shouldRetry(tries, e, deadline): 6062 tries += 1 6063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6064 continue 6065 raise plumbing.convert_error_to_porcelain(e) from e 6066 break 6067 6068 resp = models.SecretStoreUpdateResponse() 6069 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6070 plumbing_response.meta) 6071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6072 plumbing_response.rate_limit) 6073 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6074 plumbing_response.secret_store) 6075 return resp 6076 6077 def delete(self, id, timeout=None): 6078 ''' 6079 Delete removes a SecretStore by ID. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = SecretStoreDeleteRequest() 6083 6084 req.id = (id) 6085 tries = 0 6086 plumbing_response = None 6087 while True: 6088 t = None if deadline is None else deadline - time.time() 6089 try: 6090 plumbing_response = self.stub.Delete( 6091 req, 6092 metadata=self.parent.get_metadata('SecretStores.Delete', 6093 req), 6094 timeout=t) 6095 except Exception as e: 6096 if self.parent.shouldRetry(tries, e, deadline): 6097 tries += 1 6098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6099 continue 6100 raise plumbing.convert_error_to_porcelain(e) from e 6101 break 6102 6103 resp = models.SecretStoreDeleteResponse() 6104 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6105 plumbing_response.meta) 6106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6107 plumbing_response.rate_limit) 6108 return resp 6109 6110 def list(self, filter, *args, timeout=None): 6111 ''' 6112 List gets a list of SecretStores matching a given set of criteria. 6113 ''' 6114 deadline = None if timeout is None else time.time() + timeout 6115 req = SecretStoreListRequest() 6116 req.meta.CopyFrom(ListRequestMetadata()) 6117 if self.parent.page_limit > 0: 6118 req.meta.limit = self.parent.page_limit 6119 if self.parent.snapshot_datetime is not None: 6120 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6121 6122 req.filter = plumbing.quote_filter_args(filter, *args) 6123 6124 def generator(svc, req): 6125 tries = 0 6126 while True: 6127 t = None if deadline is None else deadline - time.time() 6128 try: 6129 plumbing_response = svc.stub.List( 6130 req, 6131 metadata=svc.parent.get_metadata( 6132 'SecretStores.List', req), 6133 timeout=t) 6134 except Exception as e: 6135 if self.parent.shouldRetry(tries, e, deadline): 6136 tries += 1 6137 time.sleep( 6138 self.parent.exponentialBackoff(tries, deadline)) 6139 continue 6140 raise plumbing.convert_error_to_porcelain(e) from e 6141 tries = 0 6142 for plumbing_item in plumbing_response.secret_stores: 6143 yield plumbing.convert_secret_store_to_porcelain( 6144 plumbing_item) 6145 if plumbing_response.meta.next_cursor == '': 6146 break 6147 req.meta.cursor = plumbing_response.meta.next_cursor 6148 6149 return generator(self, req) 6150 6151 6152class SnapshotSecretStores: 6153 ''' 6154 SnapshotSecretStores exposes the read only methods of the SecretStores 6155 service for historical queries. 6156 ''' 6157 def __init__(self, secret_stores): 6158 self.secret_stores = secret_stores 6159 6160 def get(self, id, timeout=None): 6161 ''' 6162 Get reads one SecretStore by ID. 6163 ''' 6164 return self.secret_stores.get(id, timeout=timeout) 6165 6166 def list(self, filter, *args, timeout=None): 6167 ''' 6168 List gets a list of SecretStores matching a given set of criteria. 6169 ''' 6170 return self.secret_stores.list(filter, *args, timeout=timeout) 6171 6172 6173class SecretEngines: 6174 ''' 6175 6176 See: 6177 `strongdm.models.ActiveDirectoryEngine` 6178 `strongdm.models.KeyValueEngine` 6179 ''' 6180 def __init__(self, channel, client): 6181 self.parent = client 6182 self.stub = SecretEnginesStub(channel) 6183 6184 def list(self, filter, *args, timeout=None): 6185 ''' 6186 List returns a list of Secret Engines 6187 ''' 6188 deadline = None if timeout is None else time.time() + timeout 6189 req = SecretEngineListRequest() 6190 req.meta.CopyFrom(ListRequestMetadata()) 6191 if self.parent.page_limit > 0: 6192 req.meta.limit = self.parent.page_limit 6193 if self.parent.snapshot_datetime is not None: 6194 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6195 6196 req.filter = plumbing.quote_filter_args(filter, *args) 6197 6198 def generator(svc, req): 6199 tries = 0 6200 while True: 6201 t = None if deadline is None else deadline - time.time() 6202 try: 6203 plumbing_response = svc.stub.List( 6204 req, 6205 metadata=svc.parent.get_metadata( 6206 'SecretEngines.List', req), 6207 timeout=t) 6208 except Exception as e: 6209 if self.parent.shouldRetry(tries, e, deadline): 6210 tries += 1 6211 time.sleep( 6212 self.parent.exponentialBackoff(tries, deadline)) 6213 continue 6214 raise plumbing.convert_error_to_porcelain(e) from e 6215 tries = 0 6216 for plumbing_item in plumbing_response.secret_engines: 6217 yield plumbing.convert_secret_engine_to_porcelain( 6218 plumbing_item) 6219 if plumbing_response.meta.next_cursor == '': 6220 break 6221 req.meta.cursor = plumbing_response.meta.next_cursor 6222 6223 return generator(self, req) 6224 6225 def get(self, id, timeout=None): 6226 ''' 6227 Get returns a secret engine details 6228 ''' 6229 deadline = None if timeout is None else time.time() + timeout 6230 req = SecretEngineGetRequest() 6231 if self.parent.snapshot_datetime is not None: 6232 req.meta.CopyFrom(GetRequestMetadata()) 6233 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6234 6235 req.id = (id) 6236 tries = 0 6237 plumbing_response = None 6238 while True: 6239 t = None if deadline is None else deadline - time.time() 6240 try: 6241 plumbing_response = self.stub.Get( 6242 req, 6243 metadata=self.parent.get_metadata('SecretEngines.Get', 6244 req), 6245 timeout=t) 6246 except Exception as e: 6247 if self.parent.shouldRetry(tries, e, deadline): 6248 tries += 1 6249 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6250 continue 6251 raise plumbing.convert_error_to_porcelain(e) from e 6252 break 6253 6254 resp = models.SecretEngineGetResponse() 6255 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6256 plumbing_response.meta) 6257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6258 plumbing_response.rate_limit) 6259 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6260 plumbing_response.secret_engine) 6261 return resp 6262 6263 def create(self, secret_engine, timeout=None): 6264 ''' 6265 Create creates a secret engine 6266 ''' 6267 deadline = None if timeout is None else time.time() + timeout 6268 req = SecretEngineCreateRequest() 6269 6270 if secret_engine is not None: 6271 req.secret_engine.CopyFrom( 6272 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6273 tries = 0 6274 plumbing_response = None 6275 while True: 6276 t = None if deadline is None else deadline - time.time() 6277 try: 6278 plumbing_response = self.stub.Create( 6279 req, 6280 metadata=self.parent.get_metadata('SecretEngines.Create', 6281 req), 6282 timeout=t) 6283 except Exception as e: 6284 if self.parent.shouldRetry(tries, e, deadline): 6285 tries += 1 6286 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6287 continue 6288 raise plumbing.convert_error_to_porcelain(e) from e 6289 break 6290 6291 resp = models.SecretEngineCreateResponse() 6292 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6293 plumbing_response.meta) 6294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6295 plumbing_response.rate_limit) 6296 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6297 plumbing_response.secret_engine) 6298 return resp 6299 6300 def update(self, secret_engine, timeout=None): 6301 ''' 6302 Update updates a secret engine 6303 ''' 6304 deadline = None if timeout is None else time.time() + timeout 6305 req = SecretEngineUpdateRequest() 6306 6307 if secret_engine is not None: 6308 req.secret_engine.CopyFrom( 6309 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6310 tries = 0 6311 plumbing_response = None 6312 while True: 6313 t = None if deadline is None else deadline - time.time() 6314 try: 6315 plumbing_response = self.stub.Update( 6316 req, 6317 metadata=self.parent.get_metadata('SecretEngines.Update', 6318 req), 6319 timeout=t) 6320 except Exception as e: 6321 if self.parent.shouldRetry(tries, e, deadline): 6322 tries += 1 6323 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6324 continue 6325 raise plumbing.convert_error_to_porcelain(e) from e 6326 break 6327 6328 resp = models.SecretEngineUpdateResponse() 6329 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6330 plumbing_response.meta) 6331 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6332 plumbing_response.rate_limit) 6333 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6334 plumbing_response.secret_engine) 6335 return resp 6336 6337 def delete(self, id, timeout=None): 6338 ''' 6339 Delete deletes a secret engine 6340 ''' 6341 deadline = None if timeout is None else time.time() + timeout 6342 req = SecretEngineDeleteRequest() 6343 6344 req.id = (id) 6345 tries = 0 6346 plumbing_response = None 6347 while True: 6348 t = None if deadline is None else deadline - time.time() 6349 try: 6350 plumbing_response = self.stub.Delete( 6351 req, 6352 metadata=self.parent.get_metadata('SecretEngines.Delete', 6353 req), 6354 timeout=t) 6355 except Exception as e: 6356 if self.parent.shouldRetry(tries, e, deadline): 6357 tries += 1 6358 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6359 continue 6360 raise plumbing.convert_error_to_porcelain(e) from e 6361 break 6362 6363 resp = models.SecretEngineDeleteResponse() 6364 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6365 plumbing_response.rate_limit) 6366 return resp 6367 6368 def list_secret_stores(self, filter, *args, timeout=None): 6369 ''' 6370 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6371 for Secret Engine 6372 ''' 6373 deadline = None if timeout is None else time.time() + timeout 6374 req = SecretStoreListRequest() 6375 req.meta.CopyFrom(ListRequestMetadata()) 6376 if self.parent.page_limit > 0: 6377 req.meta.limit = self.parent.page_limit 6378 if self.parent.snapshot_datetime is not None: 6379 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6380 6381 req.filter = plumbing.quote_filter_args(filter, *args) 6382 6383 def generator(svc, req): 6384 tries = 0 6385 while True: 6386 t = None if deadline is None else deadline - time.time() 6387 try: 6388 plumbing_response = svc.stub.ListSecretStores( 6389 req, 6390 metadata=svc.parent.get_metadata( 6391 'SecretEngines.ListSecretStores', req), 6392 timeout=t) 6393 except Exception as e: 6394 if self.parent.shouldRetry(tries, e, deadline): 6395 tries += 1 6396 time.sleep( 6397 self.parent.exponentialBackoff(tries, deadline)) 6398 continue 6399 raise plumbing.convert_error_to_porcelain(e) from e 6400 tries = 0 6401 for plumbing_item in plumbing_response.secret_stores: 6402 yield plumbing.convert_secret_store_to_porcelain( 6403 plumbing_item) 6404 if plumbing_response.meta.next_cursor == '': 6405 break 6406 req.meta.cursor = plumbing_response.meta.next_cursor 6407 6408 return generator(self, req) 6409 6410 def generate_keys(self, secret_engine_id, timeout=None): 6411 ''' 6412 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6413 ''' 6414 deadline = None if timeout is None else time.time() + timeout 6415 req = GenerateKeysRequest() 6416 6417 req.secret_engine_id = (secret_engine_id) 6418 tries = 0 6419 plumbing_response = None 6420 while True: 6421 t = None if deadline is None else deadline - time.time() 6422 try: 6423 plumbing_response = self.stub.GenerateKeys( 6424 req, 6425 metadata=self.parent.get_metadata( 6426 'SecretEngines.GenerateKeys', req), 6427 timeout=t) 6428 except Exception as e: 6429 if self.parent.shouldRetry(tries, e, deadline): 6430 tries += 1 6431 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6432 continue 6433 raise plumbing.convert_error_to_porcelain(e) from e 6434 break 6435 6436 resp = models.GenerateKeysResponse() 6437 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6438 plumbing_response.rate_limit) 6439 return resp 6440 6441 def healthcheck(self, secret_engine_id, timeout=None): 6442 ''' 6443 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6444 ''' 6445 deadline = None if timeout is None else time.time() + timeout 6446 req = HealthcheckRequest() 6447 6448 req.secret_engine_id = (secret_engine_id) 6449 tries = 0 6450 plumbing_response = None 6451 while True: 6452 t = None if deadline is None else deadline - time.time() 6453 try: 6454 plumbing_response = self.stub.Healthcheck( 6455 req, 6456 metadata=self.parent.get_metadata( 6457 'SecretEngines.Healthcheck', req), 6458 timeout=t) 6459 except Exception as e: 6460 if self.parent.shouldRetry(tries, e, deadline): 6461 tries += 1 6462 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6463 continue 6464 raise plumbing.convert_error_to_porcelain(e) from e 6465 break 6466 6467 resp = models.HealthcheckResponse() 6468 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6469 plumbing_response.rate_limit) 6470 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6471 plumbing_response.status) 6472 return resp 6473 6474 def rotate(self, id, password_policy, timeout=None): 6475 ''' 6476 Rotate rotates secret engine's credentials 6477 ''' 6478 deadline = None if timeout is None else time.time() + timeout 6479 req = SecretEngineRotateRequest() 6480 6481 req.id = (id) 6482 if password_policy is not None: 6483 req.password_policy.CopyFrom( 6484 plumbing.convert_secret_engine_password_policy_to_plumbing( 6485 password_policy)) 6486 tries = 0 6487 plumbing_response = None 6488 while True: 6489 t = None if deadline is None else deadline - time.time() 6490 try: 6491 plumbing_response = self.stub.Rotate( 6492 req, 6493 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6494 req), 6495 timeout=t) 6496 except Exception as e: 6497 if self.parent.shouldRetry(tries, e, deadline): 6498 tries += 1 6499 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6500 continue 6501 raise plumbing.convert_error_to_porcelain(e) from e 6502 break 6503 6504 resp = models.SecretEngineRotateResponse() 6505 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6506 plumbing_response.rate_limit) 6507 return resp 6508 6509 6510class SecretStoreHealths: 6511 ''' 6512 SecretStoreHealths exposes health states for secret stores. 6513 See `strongdm.models.SecretStoreHealth`. 6514 ''' 6515 def __init__(self, channel, client): 6516 self.parent = client 6517 self.stub = SecretStoreHealthsStub(channel) 6518 6519 def list(self, filter, *args, timeout=None): 6520 ''' 6521 List reports the health status of node to secret store pairs. 6522 ''' 6523 deadline = None if timeout is None else time.time() + timeout 6524 req = SecretStoreHealthListRequest() 6525 req.meta.CopyFrom(ListRequestMetadata()) 6526 if self.parent.page_limit > 0: 6527 req.meta.limit = self.parent.page_limit 6528 if self.parent.snapshot_datetime is not None: 6529 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6530 6531 req.filter = plumbing.quote_filter_args(filter, *args) 6532 6533 def generator(svc, req): 6534 tries = 0 6535 while True: 6536 t = None if deadline is None else deadline - time.time() 6537 try: 6538 plumbing_response = svc.stub.List( 6539 req, 6540 metadata=svc.parent.get_metadata( 6541 'SecretStoreHealths.List', req), 6542 timeout=t) 6543 except Exception as e: 6544 if self.parent.shouldRetry(tries, e, deadline): 6545 tries += 1 6546 time.sleep( 6547 self.parent.exponentialBackoff(tries, deadline)) 6548 continue 6549 raise plumbing.convert_error_to_porcelain(e) from e 6550 tries = 0 6551 for plumbing_item in plumbing_response.secret_store_healths: 6552 yield plumbing.convert_secret_store_health_to_porcelain( 6553 plumbing_item) 6554 if plumbing_response.meta.next_cursor == '': 6555 break 6556 req.meta.cursor = plumbing_response.meta.next_cursor 6557 6558 return generator(self, req) 6559 6560 def healthcheck(self, secret_store_id, timeout=None): 6561 ''' 6562 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6563 to propagate across a large network of Nodes. The call will return immediately, and the 6564 updated health of the Secret Store can be retrieved via List. 6565 ''' 6566 deadline = None if timeout is None else time.time() + timeout 6567 req = SecretStoreHealthcheckRequest() 6568 6569 req.secret_store_id = (secret_store_id) 6570 tries = 0 6571 plumbing_response = None 6572 while True: 6573 t = None if deadline is None else deadline - time.time() 6574 try: 6575 plumbing_response = self.stub.Healthcheck( 6576 req, 6577 metadata=self.parent.get_metadata( 6578 'SecretStoreHealths.Healthcheck', req), 6579 timeout=t) 6580 except Exception as e: 6581 if self.parent.shouldRetry(tries, e, deadline): 6582 tries += 1 6583 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6584 continue 6585 raise plumbing.convert_error_to_porcelain(e) from e 6586 break 6587 6588 resp = models.SecretStoreHealthcheckResponse() 6589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6590 plumbing_response.rate_limit) 6591 return resp 6592 6593 6594class SecretStoresHistory: 6595 ''' 6596 SecretStoresHistory records all changes to the state of a SecretStore. 6597 See `strongdm.models.SecretStoreHistory`. 6598 ''' 6599 def __init__(self, channel, client): 6600 self.parent = client 6601 self.stub = SecretStoresHistoryStub(channel) 6602 6603 def list(self, filter, *args, timeout=None): 6604 ''' 6605 List gets a list of SecretStoreHistory records matching a given set of criteria. 6606 ''' 6607 deadline = None if timeout is None else time.time() + timeout 6608 req = SecretStoreHistoryListRequest() 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 'SecretStoresHistory.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_secret_store_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 WorkflowApprovers: 6646 ''' 6647 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6648 See `strongdm.models.WorkflowApprover`. 6649 ''' 6650 def __init__(self, channel, client): 6651 self.parent = client 6652 self.stub = WorkflowApproversStub(channel) 6653 6654 def create(self, workflow_approver, timeout=None): 6655 ''' 6656 Create creates a new workflow approver 6657 ''' 6658 deadline = None if timeout is None else time.time() + timeout 6659 req = WorkflowApproversCreateRequest() 6660 6661 if workflow_approver is not None: 6662 req.workflow_approver.CopyFrom( 6663 plumbing.convert_workflow_approver_to_plumbing( 6664 workflow_approver)) 6665 tries = 0 6666 plumbing_response = None 6667 while True: 6668 t = None if deadline is None else deadline - time.time() 6669 try: 6670 plumbing_response = self.stub.Create( 6671 req, 6672 metadata=self.parent.get_metadata( 6673 'WorkflowApprovers.Create', req), 6674 timeout=t) 6675 except Exception as e: 6676 if self.parent.shouldRetry(tries, e, deadline): 6677 tries += 1 6678 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6679 continue 6680 raise plumbing.convert_error_to_porcelain(e) from e 6681 break 6682 6683 resp = models.WorkflowApproversCreateResponse() 6684 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6685 plumbing_response.rate_limit) 6686 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6687 plumbing_response.workflow_approver) 6688 return resp 6689 6690 def get(self, id, timeout=None): 6691 ''' 6692 Get reads one workflow approver by ID. 6693 ''' 6694 deadline = None if timeout is None else time.time() + timeout 6695 req = WorkflowApproverGetRequest() 6696 if self.parent.snapshot_datetime is not None: 6697 req.meta.CopyFrom(GetRequestMetadata()) 6698 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6699 6700 req.id = (id) 6701 tries = 0 6702 plumbing_response = None 6703 while True: 6704 t = None if deadline is None else deadline - time.time() 6705 try: 6706 plumbing_response = self.stub.Get( 6707 req, 6708 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6709 req), 6710 timeout=t) 6711 except Exception as e: 6712 if self.parent.shouldRetry(tries, e, deadline): 6713 tries += 1 6714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6715 continue 6716 raise plumbing.convert_error_to_porcelain(e) from e 6717 break 6718 6719 resp = models.WorkflowApproverGetResponse() 6720 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6721 plumbing_response.meta) 6722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6723 plumbing_response.rate_limit) 6724 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6725 plumbing_response.workflow_approver) 6726 return resp 6727 6728 def delete(self, id, timeout=None): 6729 ''' 6730 Delete deletes a workflow approver 6731 ''' 6732 deadline = None if timeout is None else time.time() + timeout 6733 req = WorkflowApproversDeleteRequest() 6734 6735 req.id = (id) 6736 tries = 0 6737 plumbing_response = None 6738 while True: 6739 t = None if deadline is None else deadline - time.time() 6740 try: 6741 plumbing_response = self.stub.Delete( 6742 req, 6743 metadata=self.parent.get_metadata( 6744 'WorkflowApprovers.Delete', req), 6745 timeout=t) 6746 except Exception as e: 6747 if self.parent.shouldRetry(tries, e, deadline): 6748 tries += 1 6749 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6750 continue 6751 raise plumbing.convert_error_to_porcelain(e) from e 6752 break 6753 6754 resp = models.WorkflowApproversDeleteResponse() 6755 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6756 plumbing_response.rate_limit) 6757 return resp 6758 6759 def list(self, filter, *args, timeout=None): 6760 ''' 6761 Lists existing workflow approvers. 6762 ''' 6763 deadline = None if timeout is None else time.time() + timeout 6764 req = WorkflowApproversListRequest() 6765 req.meta.CopyFrom(ListRequestMetadata()) 6766 if self.parent.page_limit > 0: 6767 req.meta.limit = self.parent.page_limit 6768 if self.parent.snapshot_datetime is not None: 6769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6770 6771 req.filter = plumbing.quote_filter_args(filter, *args) 6772 6773 def generator(svc, req): 6774 tries = 0 6775 while True: 6776 t = None if deadline is None else deadline - time.time() 6777 try: 6778 plumbing_response = svc.stub.List( 6779 req, 6780 metadata=svc.parent.get_metadata( 6781 'WorkflowApprovers.List', req), 6782 timeout=t) 6783 except Exception as e: 6784 if self.parent.shouldRetry(tries, e, deadline): 6785 tries += 1 6786 time.sleep( 6787 self.parent.exponentialBackoff(tries, deadline)) 6788 continue 6789 raise plumbing.convert_error_to_porcelain(e) from e 6790 tries = 0 6791 for plumbing_item in plumbing_response.workflow_approvers: 6792 yield plumbing.convert_workflow_approver_to_porcelain( 6793 plumbing_item) 6794 if plumbing_response.meta.next_cursor == '': 6795 break 6796 req.meta.cursor = plumbing_response.meta.next_cursor 6797 6798 return generator(self, req) 6799 6800 6801class SnapshotWorkflowApprovers: 6802 ''' 6803 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6804 service for historical queries. 6805 ''' 6806 def __init__(self, workflow_approvers): 6807 self.workflow_approvers = workflow_approvers 6808 6809 def get(self, id, timeout=None): 6810 ''' 6811 Get reads one workflow approver by ID. 6812 ''' 6813 return self.workflow_approvers.get(id, timeout=timeout) 6814 6815 def list(self, filter, *args, timeout=None): 6816 ''' 6817 Lists existing workflow approvers. 6818 ''' 6819 return self.workflow_approvers.list(filter, *args, timeout=timeout) 6820 6821 6822class WorkflowApproversHistory: 6823 ''' 6824 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6825 See `strongdm.models.WorkflowApproverHistory`. 6826 ''' 6827 def __init__(self, channel, client): 6828 self.parent = client 6829 self.stub = WorkflowApproversHistoryStub(channel) 6830 6831 def list(self, filter, *args, timeout=None): 6832 ''' 6833 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6834 ''' 6835 deadline = None if timeout is None else time.time() + timeout 6836 req = WorkflowApproversHistoryListRequest() 6837 req.meta.CopyFrom(ListRequestMetadata()) 6838 if self.parent.page_limit > 0: 6839 req.meta.limit = self.parent.page_limit 6840 if self.parent.snapshot_datetime is not None: 6841 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6842 6843 req.filter = plumbing.quote_filter_args(filter, *args) 6844 6845 def generator(svc, req): 6846 tries = 0 6847 while True: 6848 t = None if deadline is None else deadline - time.time() 6849 try: 6850 plumbing_response = svc.stub.List( 6851 req, 6852 metadata=svc.parent.get_metadata( 6853 'WorkflowApproversHistory.List', req), 6854 timeout=t) 6855 except Exception as e: 6856 if self.parent.shouldRetry(tries, e, deadline): 6857 tries += 1 6858 time.sleep( 6859 self.parent.exponentialBackoff(tries, deadline)) 6860 continue 6861 raise plumbing.convert_error_to_porcelain(e) from e 6862 tries = 0 6863 for plumbing_item in plumbing_response.history: 6864 yield plumbing.convert_workflow_approver_history_to_porcelain( 6865 plumbing_item) 6866 if plumbing_response.meta.next_cursor == '': 6867 break 6868 req.meta.cursor = plumbing_response.meta.next_cursor 6869 6870 return generator(self, req) 6871 6872 6873class WorkflowRoles: 6874 ''' 6875 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6876 to request access to a resource via the workflow. 6877 See `strongdm.models.WorkflowRole`. 6878 ''' 6879 def __init__(self, channel, client): 6880 self.parent = client 6881 self.stub = WorkflowRolesStub(channel) 6882 6883 def create(self, workflow_role, timeout=None): 6884 ''' 6885 Create creates a new workflow role 6886 ''' 6887 deadline = None if timeout is None else time.time() + timeout 6888 req = WorkflowRolesCreateRequest() 6889 6890 if workflow_role is not None: 6891 req.workflow_role.CopyFrom( 6892 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6893 tries = 0 6894 plumbing_response = None 6895 while True: 6896 t = None if deadline is None else deadline - time.time() 6897 try: 6898 plumbing_response = self.stub.Create( 6899 req, 6900 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6901 req), 6902 timeout=t) 6903 except Exception as e: 6904 if self.parent.shouldRetry(tries, e, deadline): 6905 tries += 1 6906 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6907 continue 6908 raise plumbing.convert_error_to_porcelain(e) from e 6909 break 6910 6911 resp = models.WorkflowRolesCreateResponse() 6912 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6913 plumbing_response.rate_limit) 6914 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6915 plumbing_response.workflow_role) 6916 return resp 6917 6918 def get(self, id, timeout=None): 6919 ''' 6920 Get reads one workflow role by ID. 6921 ''' 6922 deadline = None if timeout is None else time.time() + timeout 6923 req = WorkflowRoleGetRequest() 6924 if self.parent.snapshot_datetime is not None: 6925 req.meta.CopyFrom(GetRequestMetadata()) 6926 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6927 6928 req.id = (id) 6929 tries = 0 6930 plumbing_response = None 6931 while True: 6932 t = None if deadline is None else deadline - time.time() 6933 try: 6934 plumbing_response = self.stub.Get( 6935 req, 6936 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6937 req), 6938 timeout=t) 6939 except Exception as e: 6940 if self.parent.shouldRetry(tries, e, deadline): 6941 tries += 1 6942 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6943 continue 6944 raise plumbing.convert_error_to_porcelain(e) from e 6945 break 6946 6947 resp = models.WorkflowRoleGetResponse() 6948 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6949 plumbing_response.meta) 6950 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6951 plumbing_response.rate_limit) 6952 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6953 plumbing_response.workflow_role) 6954 return resp 6955 6956 def delete(self, id, timeout=None): 6957 ''' 6958 Delete deletes a workflow role 6959 ''' 6960 deadline = None if timeout is None else time.time() + timeout 6961 req = WorkflowRolesDeleteRequest() 6962 6963 req.id = (id) 6964 tries = 0 6965 plumbing_response = None 6966 while True: 6967 t = None if deadline is None else deadline - time.time() 6968 try: 6969 plumbing_response = self.stub.Delete( 6970 req, 6971 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6972 req), 6973 timeout=t) 6974 except Exception as e: 6975 if self.parent.shouldRetry(tries, e, deadline): 6976 tries += 1 6977 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6978 continue 6979 raise plumbing.convert_error_to_porcelain(e) from e 6980 break 6981 6982 resp = models.WorkflowRolesDeleteResponse() 6983 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6984 plumbing_response.rate_limit) 6985 return resp 6986 6987 def list(self, filter, *args, timeout=None): 6988 ''' 6989 Lists existing workflow roles. 6990 ''' 6991 deadline = None if timeout is None else time.time() + timeout 6992 req = WorkflowRolesListRequest() 6993 req.meta.CopyFrom(ListRequestMetadata()) 6994 if self.parent.page_limit > 0: 6995 req.meta.limit = self.parent.page_limit 6996 if self.parent.snapshot_datetime is not None: 6997 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6998 6999 req.filter = plumbing.quote_filter_args(filter, *args) 7000 7001 def generator(svc, req): 7002 tries = 0 7003 while True: 7004 t = None if deadline is None else deadline - time.time() 7005 try: 7006 plumbing_response = svc.stub.List( 7007 req, 7008 metadata=svc.parent.get_metadata( 7009 'WorkflowRoles.List', req), 7010 timeout=t) 7011 except Exception as e: 7012 if self.parent.shouldRetry(tries, e, deadline): 7013 tries += 1 7014 time.sleep( 7015 self.parent.exponentialBackoff(tries, deadline)) 7016 continue 7017 raise plumbing.convert_error_to_porcelain(e) from e 7018 tries = 0 7019 for plumbing_item in plumbing_response.workflow_role: 7020 yield plumbing.convert_workflow_role_to_porcelain( 7021 plumbing_item) 7022 if plumbing_response.meta.next_cursor == '': 7023 break 7024 req.meta.cursor = plumbing_response.meta.next_cursor 7025 7026 return generator(self, req) 7027 7028 7029class SnapshotWorkflowRoles: 7030 ''' 7031 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7032 service for historical queries. 7033 ''' 7034 def __init__(self, workflow_roles): 7035 self.workflow_roles = workflow_roles 7036 7037 def get(self, id, timeout=None): 7038 ''' 7039 Get reads one workflow role by ID. 7040 ''' 7041 return self.workflow_roles.get(id, timeout=timeout) 7042 7043 def list(self, filter, *args, timeout=None): 7044 ''' 7045 Lists existing workflow roles. 7046 ''' 7047 return self.workflow_roles.list(filter, *args, timeout=timeout) 7048 7049 7050class WorkflowRolesHistory: 7051 ''' 7052 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7053 See `strongdm.models.WorkflowRoleHistory`. 7054 ''' 7055 def __init__(self, channel, client): 7056 self.parent = client 7057 self.stub = WorkflowRolesHistoryStub(channel) 7058 7059 def list(self, filter, *args, timeout=None): 7060 ''' 7061 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7062 ''' 7063 deadline = None if timeout is None else time.time() + timeout 7064 req = WorkflowRolesHistoryListRequest() 7065 req.meta.CopyFrom(ListRequestMetadata()) 7066 if self.parent.page_limit > 0: 7067 req.meta.limit = self.parent.page_limit 7068 if self.parent.snapshot_datetime is not None: 7069 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7070 7071 req.filter = plumbing.quote_filter_args(filter, *args) 7072 7073 def generator(svc, req): 7074 tries = 0 7075 while True: 7076 t = None if deadline is None else deadline - time.time() 7077 try: 7078 plumbing_response = svc.stub.List( 7079 req, 7080 metadata=svc.parent.get_metadata( 7081 'WorkflowRolesHistory.List', req), 7082 timeout=t) 7083 except Exception as e: 7084 if self.parent.shouldRetry(tries, e, deadline): 7085 tries += 1 7086 time.sleep( 7087 self.parent.exponentialBackoff(tries, deadline)) 7088 continue 7089 raise plumbing.convert_error_to_porcelain(e) from e 7090 tries = 0 7091 for plumbing_item in plumbing_response.history: 7092 yield plumbing.convert_workflow_role_history_to_porcelain( 7093 plumbing_item) 7094 if plumbing_response.meta.next_cursor == '': 7095 break 7096 req.meta.cursor = plumbing_response.meta.next_cursor 7097 7098 return generator(self, req) 7099 7100 7101class Workflows: 7102 ''' 7103 Workflows are the collection of rules that define the resources to which access can be requested, 7104 the users that can request that access, and the mechanism for approving those requests which can either 7105 be automatic approval or a set of users authorized to approve the requests. 7106 See `strongdm.models.Workflow`. 7107 ''' 7108 def __init__(self, channel, client): 7109 self.parent = client 7110 self.stub = WorkflowsStub(channel) 7111 7112 def create(self, workflow, timeout=None): 7113 ''' 7114 Create creates a new workflow and requires a name for the workflow. 7115 ''' 7116 deadline = None if timeout is None else time.time() + timeout 7117 req = WorkflowCreateRequest() 7118 7119 if workflow is not None: 7120 req.workflow.CopyFrom( 7121 plumbing.convert_workflow_to_plumbing(workflow)) 7122 tries = 0 7123 plumbing_response = None 7124 while True: 7125 t = None if deadline is None else deadline - time.time() 7126 try: 7127 plumbing_response = self.stub.Create( 7128 req, 7129 metadata=self.parent.get_metadata('Workflows.Create', req), 7130 timeout=t) 7131 except Exception as e: 7132 if self.parent.shouldRetry(tries, e, deadline): 7133 tries += 1 7134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7135 continue 7136 raise plumbing.convert_error_to_porcelain(e) from e 7137 break 7138 7139 resp = models.WorkflowCreateResponse() 7140 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7141 plumbing_response.rate_limit) 7142 resp.workflow = plumbing.convert_workflow_to_porcelain( 7143 plumbing_response.workflow) 7144 return resp 7145 7146 def get(self, id, timeout=None): 7147 ''' 7148 Get reads one workflow by ID. 7149 ''' 7150 deadline = None if timeout is None else time.time() + timeout 7151 req = WorkflowGetRequest() 7152 if self.parent.snapshot_datetime is not None: 7153 req.meta.CopyFrom(GetRequestMetadata()) 7154 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7155 7156 req.id = (id) 7157 tries = 0 7158 plumbing_response = None 7159 while True: 7160 t = None if deadline is None else deadline - time.time() 7161 try: 7162 plumbing_response = self.stub.Get( 7163 req, 7164 metadata=self.parent.get_metadata('Workflows.Get', req), 7165 timeout=t) 7166 except Exception as e: 7167 if self.parent.shouldRetry(tries, e, deadline): 7168 tries += 1 7169 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7170 continue 7171 raise plumbing.convert_error_to_porcelain(e) from e 7172 break 7173 7174 resp = models.WorkflowGetResponse() 7175 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7176 plumbing_response.meta) 7177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7178 plumbing_response.rate_limit) 7179 resp.workflow = plumbing.convert_workflow_to_porcelain( 7180 plumbing_response.workflow) 7181 return resp 7182 7183 def delete(self, id, timeout=None): 7184 ''' 7185 Delete deletes an existing workflow. 7186 ''' 7187 deadline = None if timeout is None else time.time() + timeout 7188 req = WorkflowDeleteRequest() 7189 7190 req.id = (id) 7191 tries = 0 7192 plumbing_response = None 7193 while True: 7194 t = None if deadline is None else deadline - time.time() 7195 try: 7196 plumbing_response = self.stub.Delete( 7197 req, 7198 metadata=self.parent.get_metadata('Workflows.Delete', req), 7199 timeout=t) 7200 except Exception as e: 7201 if self.parent.shouldRetry(tries, e, deadline): 7202 tries += 1 7203 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7204 continue 7205 raise plumbing.convert_error_to_porcelain(e) from e 7206 break 7207 7208 resp = models.WorkflowDeleteResponse() 7209 resp.id = (plumbing_response.id) 7210 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7211 plumbing_response.rate_limit) 7212 return resp 7213 7214 def update(self, workflow, timeout=None): 7215 ''' 7216 Update updates an existing workflow. 7217 ''' 7218 deadline = None if timeout is None else time.time() + timeout 7219 req = WorkflowUpdateRequest() 7220 7221 if workflow is not None: 7222 req.workflow.CopyFrom( 7223 plumbing.convert_workflow_to_plumbing(workflow)) 7224 tries = 0 7225 plumbing_response = None 7226 while True: 7227 t = None if deadline is None else deadline - time.time() 7228 try: 7229 plumbing_response = self.stub.Update( 7230 req, 7231 metadata=self.parent.get_metadata('Workflows.Update', req), 7232 timeout=t) 7233 except Exception as e: 7234 if self.parent.shouldRetry(tries, e, deadline): 7235 tries += 1 7236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7237 continue 7238 raise plumbing.convert_error_to_porcelain(e) from e 7239 break 7240 7241 resp = models.WorkflowUpdateResponse() 7242 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7243 plumbing_response.rate_limit) 7244 resp.workflow = plumbing.convert_workflow_to_porcelain( 7245 plumbing_response.workflow) 7246 return resp 7247 7248 def list(self, filter, *args, timeout=None): 7249 ''' 7250 Lists existing workflows. 7251 ''' 7252 deadline = None if timeout is None else time.time() + timeout 7253 req = WorkflowListRequest() 7254 req.meta.CopyFrom(ListRequestMetadata()) 7255 if self.parent.page_limit > 0: 7256 req.meta.limit = self.parent.page_limit 7257 if self.parent.snapshot_datetime is not None: 7258 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7259 7260 req.filter = plumbing.quote_filter_args(filter, *args) 7261 7262 def generator(svc, req): 7263 tries = 0 7264 while True: 7265 t = None if deadline is None else deadline - time.time() 7266 try: 7267 plumbing_response = svc.stub.List( 7268 req, 7269 metadata=svc.parent.get_metadata( 7270 'Workflows.List', req), 7271 timeout=t) 7272 except Exception as e: 7273 if self.parent.shouldRetry(tries, e, deadline): 7274 tries += 1 7275 time.sleep( 7276 self.parent.exponentialBackoff(tries, deadline)) 7277 continue 7278 raise plumbing.convert_error_to_porcelain(e) from e 7279 tries = 0 7280 for plumbing_item in plumbing_response.workflows: 7281 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7282 if plumbing_response.meta.next_cursor == '': 7283 break 7284 req.meta.cursor = plumbing_response.meta.next_cursor 7285 7286 return generator(self, req) 7287 7288 7289class SnapshotWorkflows: 7290 ''' 7291 SnapshotWorkflows exposes the read only methods of the Workflows 7292 service for historical queries. 7293 ''' 7294 def __init__(self, workflows): 7295 self.workflows = workflows 7296 7297 def get(self, id, timeout=None): 7298 ''' 7299 Get reads one workflow by ID. 7300 ''' 7301 return self.workflows.get(id, timeout=timeout) 7302 7303 def list(self, filter, *args, timeout=None): 7304 ''' 7305 Lists existing workflows. 7306 ''' 7307 return self.workflows.list(filter, *args, timeout=timeout) 7308 7309 7310class WorkflowsHistory: 7311 ''' 7312 WorkflowsHistory provides records of all changes to the state of a Workflow. 7313 See `strongdm.models.WorkflowHistory`. 7314 ''' 7315 def __init__(self, channel, client): 7316 self.parent = client 7317 self.stub = WorkflowsHistoryStub(channel) 7318 7319 def list(self, filter, *args, timeout=None): 7320 ''' 7321 List gets a list of WorkflowHistory records matching a given set of criteria. 7322 ''' 7323 deadline = None if timeout is None else time.time() + timeout 7324 req = WorkflowHistoryListRequest() 7325 req.meta.CopyFrom(ListRequestMetadata()) 7326 if self.parent.page_limit > 0: 7327 req.meta.limit = self.parent.page_limit 7328 if self.parent.snapshot_datetime is not None: 7329 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7330 7331 req.filter = plumbing.quote_filter_args(filter, *args) 7332 7333 def generator(svc, req): 7334 tries = 0 7335 while True: 7336 t = None if deadline is None else deadline - time.time() 7337 try: 7338 plumbing_response = svc.stub.List( 7339 req, 7340 metadata=svc.parent.get_metadata( 7341 'WorkflowsHistory.List', req), 7342 timeout=t) 7343 except Exception as e: 7344 if self.parent.shouldRetry(tries, e, deadline): 7345 tries += 1 7346 time.sleep( 7347 self.parent.exponentialBackoff(tries, deadline)) 7348 continue 7349 raise plumbing.convert_error_to_porcelain(e) from e 7350 tries = 0 7351 for plumbing_item in plumbing_response.history: 7352 yield plumbing.convert_workflow_history_to_porcelain( 7353 plumbing_item) 7354 if plumbing_response.meta.next_cursor == '': 7355 break 7356 req.meta.cursor = plumbing_response.meta.next_cursor 7357 7358 return generator(self, req)
def
deprecated(func)
157def deprecated(func): 158 """This is a decorator which can be used to mark functions 159 as deprecated. It will result in a warning being emitted 160 when the function is used.""" 161 @functools.wraps(func) 162 def new_func(*args, **kwargs): 163 warnings.warn("Call to deprecated function {}.".format(func.__name__), 164 category=DeprecationWarning, 165 stacklevel=2) 166 return func(*args, **kwargs) 167 168 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:
171class AccessRequests: 172 ''' 173 AccessRequests are requests for access to a resource that may match a Workflow. 174 See `strongdm.models.AccessRequest`. 175 ''' 176 def __init__(self, channel, client): 177 self.parent = client 178 self.stub = AccessRequestsStub(channel) 179 180 def list(self, filter, *args, timeout=None): 181 ''' 182 Lists existing access requests. 183 ''' 184 deadline = None if timeout is None else time.time() + timeout 185 req = AccessRequestListRequest() 186 req.meta.CopyFrom(ListRequestMetadata()) 187 if self.parent.page_limit > 0: 188 req.meta.limit = self.parent.page_limit 189 if self.parent.snapshot_datetime is not None: 190 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 191 192 req.filter = plumbing.quote_filter_args(filter, *args) 193 194 def generator(svc, req): 195 tries = 0 196 while True: 197 t = None if deadline is None else deadline - time.time() 198 try: 199 plumbing_response = svc.stub.List( 200 req, 201 metadata=svc.parent.get_metadata( 202 'AccessRequests.List', req), 203 timeout=t) 204 except Exception as e: 205 if self.parent.shouldRetry(tries, e, deadline): 206 tries += 1 207 time.sleep( 208 self.parent.exponentialBackoff(tries, deadline)) 209 continue 210 raise plumbing.convert_error_to_porcelain(e) from e 211 tries = 0 212 for plumbing_item in plumbing_response.access_requests: 213 yield plumbing.convert_access_request_to_porcelain( 214 plumbing_item) 215 if plumbing_response.meta.next_cursor == '': 216 break 217 req.meta.cursor = plumbing_response.meta.next_cursor 218 219 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)
180 def list(self, filter, *args, timeout=None): 181 ''' 182 Lists existing access requests. 183 ''' 184 deadline = None if timeout is None else time.time() + timeout 185 req = AccessRequestListRequest() 186 req.meta.CopyFrom(ListRequestMetadata()) 187 if self.parent.page_limit > 0: 188 req.meta.limit = self.parent.page_limit 189 if self.parent.snapshot_datetime is not None: 190 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 191 192 req.filter = plumbing.quote_filter_args(filter, *args) 193 194 def generator(svc, req): 195 tries = 0 196 while True: 197 t = None if deadline is None else deadline - time.time() 198 try: 199 plumbing_response = svc.stub.List( 200 req, 201 metadata=svc.parent.get_metadata( 202 'AccessRequests.List', req), 203 timeout=t) 204 except Exception as e: 205 if self.parent.shouldRetry(tries, e, deadline): 206 tries += 1 207 time.sleep( 208 self.parent.exponentialBackoff(tries, deadline)) 209 continue 210 raise plumbing.convert_error_to_porcelain(e) from e 211 tries = 0 212 for plumbing_item in plumbing_response.access_requests: 213 yield plumbing.convert_access_request_to_porcelain( 214 plumbing_item) 215 if plumbing_response.meta.next_cursor == '': 216 break 217 req.meta.cursor = plumbing_response.meta.next_cursor 218 219 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
222class SnapshotAccessRequests: 223 ''' 224 SnapshotAccessRequests exposes the read only methods of the AccessRequests 225 service for historical queries. 226 ''' 227 def __init__(self, access_requests): 228 self.access_requests = access_requests 229 230 def list(self, filter, *args, timeout=None): 231 ''' 232 Lists existing access requests. 233 ''' 234 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
237class AccessRequestEventsHistory: 238 ''' 239 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 240 See `strongdm.models.AccessRequestEventHistory`. 241 ''' 242 def __init__(self, channel, client): 243 self.parent = client 244 self.stub = AccessRequestEventsHistoryStub(channel) 245 246 def list(self, filter, *args, timeout=None): 247 ''' 248 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 249 ''' 250 deadline = None if timeout is None else time.time() + timeout 251 req = AccessRequestEventHistoryListRequest() 252 req.meta.CopyFrom(ListRequestMetadata()) 253 if self.parent.page_limit > 0: 254 req.meta.limit = self.parent.page_limit 255 if self.parent.snapshot_datetime is not None: 256 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 257 258 req.filter = plumbing.quote_filter_args(filter, *args) 259 260 def generator(svc, req): 261 tries = 0 262 while True: 263 t = None if deadline is None else deadline - time.time() 264 try: 265 plumbing_response = svc.stub.List( 266 req, 267 metadata=svc.parent.get_metadata( 268 'AccessRequestEventsHistory.List', req), 269 timeout=t) 270 except Exception as e: 271 if self.parent.shouldRetry(tries, e, deadline): 272 tries += 1 273 time.sleep( 274 self.parent.exponentialBackoff(tries, deadline)) 275 continue 276 raise plumbing.convert_error_to_porcelain(e) from e 277 tries = 0 278 for plumbing_item in plumbing_response.history: 279 yield plumbing.convert_access_request_event_history_to_porcelain( 280 plumbing_item) 281 if plumbing_response.meta.next_cursor == '': 282 break 283 req.meta.cursor = plumbing_response.meta.next_cursor 284 285 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)
246 def list(self, filter, *args, timeout=None): 247 ''' 248 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 249 ''' 250 deadline = None if timeout is None else time.time() + timeout 251 req = AccessRequestEventHistoryListRequest() 252 req.meta.CopyFrom(ListRequestMetadata()) 253 if self.parent.page_limit > 0: 254 req.meta.limit = self.parent.page_limit 255 if self.parent.snapshot_datetime is not None: 256 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 257 258 req.filter = plumbing.quote_filter_args(filter, *args) 259 260 def generator(svc, req): 261 tries = 0 262 while True: 263 t = None if deadline is None else deadline - time.time() 264 try: 265 plumbing_response = svc.stub.List( 266 req, 267 metadata=svc.parent.get_metadata( 268 'AccessRequestEventsHistory.List', req), 269 timeout=t) 270 except Exception as e: 271 if self.parent.shouldRetry(tries, e, deadline): 272 tries += 1 273 time.sleep( 274 self.parent.exponentialBackoff(tries, deadline)) 275 continue 276 raise plumbing.convert_error_to_porcelain(e) from e 277 tries = 0 278 for plumbing_item in plumbing_response.history: 279 yield plumbing.convert_access_request_event_history_to_porcelain( 280 plumbing_item) 281 if plumbing_response.meta.next_cursor == '': 282 break 283 req.meta.cursor = plumbing_response.meta.next_cursor 284 285 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
288class AccessRequestsHistory: 289 ''' 290 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 291 See `strongdm.models.AccessRequestHistory`. 292 ''' 293 def __init__(self, channel, client): 294 self.parent = client 295 self.stub = AccessRequestsHistoryStub(channel) 296 297 def list(self, filter, *args, timeout=None): 298 ''' 299 List gets a list of AccessRequestHistory records matching a given set of criteria. 300 ''' 301 deadline = None if timeout is None else time.time() + timeout 302 req = AccessRequestHistoryListRequest() 303 req.meta.CopyFrom(ListRequestMetadata()) 304 if self.parent.page_limit > 0: 305 req.meta.limit = self.parent.page_limit 306 if self.parent.snapshot_datetime is not None: 307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 308 309 req.filter = plumbing.quote_filter_args(filter, *args) 310 311 def generator(svc, req): 312 tries = 0 313 while True: 314 t = None if deadline is None else deadline - time.time() 315 try: 316 plumbing_response = svc.stub.List( 317 req, 318 metadata=svc.parent.get_metadata( 319 'AccessRequestsHistory.List', req), 320 timeout=t) 321 except Exception as e: 322 if self.parent.shouldRetry(tries, e, deadline): 323 tries += 1 324 time.sleep( 325 self.parent.exponentialBackoff(tries, deadline)) 326 continue 327 raise plumbing.convert_error_to_porcelain(e) from e 328 tries = 0 329 for plumbing_item in plumbing_response.history: 330 yield plumbing.convert_access_request_history_to_porcelain( 331 plumbing_item) 332 if plumbing_response.meta.next_cursor == '': 333 break 334 req.meta.cursor = plumbing_response.meta.next_cursor 335 336 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)
297 def list(self, filter, *args, timeout=None): 298 ''' 299 List gets a list of AccessRequestHistory records matching a given set of criteria. 300 ''' 301 deadline = None if timeout is None else time.time() + timeout 302 req = AccessRequestHistoryListRequest() 303 req.meta.CopyFrom(ListRequestMetadata()) 304 if self.parent.page_limit > 0: 305 req.meta.limit = self.parent.page_limit 306 if self.parent.snapshot_datetime is not None: 307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 308 309 req.filter = plumbing.quote_filter_args(filter, *args) 310 311 def generator(svc, req): 312 tries = 0 313 while True: 314 t = None if deadline is None else deadline - time.time() 315 try: 316 plumbing_response = svc.stub.List( 317 req, 318 metadata=svc.parent.get_metadata( 319 'AccessRequestsHistory.List', req), 320 timeout=t) 321 except Exception as e: 322 if self.parent.shouldRetry(tries, e, deadline): 323 tries += 1 324 time.sleep( 325 self.parent.exponentialBackoff(tries, deadline)) 326 continue 327 raise plumbing.convert_error_to_porcelain(e) from e 328 tries = 0 329 for plumbing_item in plumbing_response.history: 330 yield plumbing.convert_access_request_history_to_porcelain( 331 plumbing_item) 332 if plumbing_response.meta.next_cursor == '': 333 break 334 req.meta.cursor = plumbing_response.meta.next_cursor 335 336 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
339class AccountAttachments: 340 ''' 341 AccountAttachments assign an account to a role. 342 See `strongdm.models.AccountAttachment`. 343 ''' 344 def __init__(self, channel, client): 345 self.parent = client 346 self.stub = AccountAttachmentsStub(channel) 347 348 def create(self, account_attachment, timeout=None): 349 ''' 350 Create registers a new AccountAttachment. 351 ''' 352 deadline = None if timeout is None else time.time() + timeout 353 req = AccountAttachmentCreateRequest() 354 355 if account_attachment is not None: 356 req.account_attachment.CopyFrom( 357 plumbing.convert_account_attachment_to_plumbing( 358 account_attachment)) 359 tries = 0 360 plumbing_response = None 361 while True: 362 t = None if deadline is None else deadline - time.time() 363 try: 364 plumbing_response = self.stub.Create( 365 req, 366 metadata=self.parent.get_metadata( 367 'AccountAttachments.Create', req), 368 timeout=t) 369 except Exception as e: 370 if self.parent.shouldRetry(tries, e, deadline): 371 tries += 1 372 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 373 continue 374 raise plumbing.convert_error_to_porcelain(e) from e 375 break 376 377 resp = models.AccountAttachmentCreateResponse() 378 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 379 plumbing_response.account_attachment) 380 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 381 plumbing_response.meta) 382 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 383 plumbing_response.rate_limit) 384 return resp 385 386 def get(self, id, timeout=None): 387 ''' 388 Get reads one AccountAttachment by ID. 389 ''' 390 deadline = None if timeout is None else time.time() + timeout 391 req = AccountAttachmentGetRequest() 392 if self.parent.snapshot_datetime is not None: 393 req.meta.CopyFrom(GetRequestMetadata()) 394 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 395 396 req.id = (id) 397 tries = 0 398 plumbing_response = None 399 while True: 400 t = None if deadline is None else deadline - time.time() 401 try: 402 plumbing_response = self.stub.Get( 403 req, 404 metadata=self.parent.get_metadata('AccountAttachments.Get', 405 req), 406 timeout=t) 407 except Exception as e: 408 if self.parent.shouldRetry(tries, e, deadline): 409 tries += 1 410 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 411 continue 412 raise plumbing.convert_error_to_porcelain(e) from e 413 break 414 415 resp = models.AccountAttachmentGetResponse() 416 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 417 plumbing_response.account_attachment) 418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 419 plumbing_response.meta) 420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 421 plumbing_response.rate_limit) 422 return resp 423 424 def delete(self, id, timeout=None): 425 ''' 426 Delete removes a AccountAttachment by ID. 427 ''' 428 deadline = None if timeout is None else time.time() + timeout 429 req = AccountAttachmentDeleteRequest() 430 431 req.id = (id) 432 tries = 0 433 plumbing_response = None 434 while True: 435 t = None if deadline is None else deadline - time.time() 436 try: 437 plumbing_response = self.stub.Delete( 438 req, 439 metadata=self.parent.get_metadata( 440 'AccountAttachments.Delete', req), 441 timeout=t) 442 except Exception as e: 443 if self.parent.shouldRetry(tries, e, deadline): 444 tries += 1 445 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 446 continue 447 raise plumbing.convert_error_to_porcelain(e) from e 448 break 449 450 resp = models.AccountAttachmentDeleteResponse() 451 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 452 plumbing_response.meta) 453 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 454 plumbing_response.rate_limit) 455 return resp 456 457 def list(self, filter, *args, timeout=None): 458 ''' 459 List gets a list of AccountAttachments matching a given set of criteria. 460 ''' 461 deadline = None if timeout is None else time.time() + timeout 462 req = AccountAttachmentListRequest() 463 req.meta.CopyFrom(ListRequestMetadata()) 464 if self.parent.page_limit > 0: 465 req.meta.limit = self.parent.page_limit 466 if self.parent.snapshot_datetime is not None: 467 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 468 469 req.filter = plumbing.quote_filter_args(filter, *args) 470 471 def generator(svc, req): 472 tries = 0 473 while True: 474 t = None if deadline is None else deadline - time.time() 475 try: 476 plumbing_response = svc.stub.List( 477 req, 478 metadata=svc.parent.get_metadata( 479 'AccountAttachments.List', req), 480 timeout=t) 481 except Exception as e: 482 if self.parent.shouldRetry(tries, e, deadline): 483 tries += 1 484 time.sleep( 485 self.parent.exponentialBackoff(tries, deadline)) 486 continue 487 raise plumbing.convert_error_to_porcelain(e) from e 488 tries = 0 489 for plumbing_item in plumbing_response.account_attachments: 490 yield plumbing.convert_account_attachment_to_porcelain( 491 plumbing_item) 492 if plumbing_response.meta.next_cursor == '': 493 break 494 req.meta.cursor = plumbing_response.meta.next_cursor 495 496 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
348 def create(self, account_attachment, timeout=None): 349 ''' 350 Create registers a new AccountAttachment. 351 ''' 352 deadline = None if timeout is None else time.time() + timeout 353 req = AccountAttachmentCreateRequest() 354 355 if account_attachment is not None: 356 req.account_attachment.CopyFrom( 357 plumbing.convert_account_attachment_to_plumbing( 358 account_attachment)) 359 tries = 0 360 plumbing_response = None 361 while True: 362 t = None if deadline is None else deadline - time.time() 363 try: 364 plumbing_response = self.stub.Create( 365 req, 366 metadata=self.parent.get_metadata( 367 'AccountAttachments.Create', req), 368 timeout=t) 369 except Exception as e: 370 if self.parent.shouldRetry(tries, e, deadline): 371 tries += 1 372 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 373 continue 374 raise plumbing.convert_error_to_porcelain(e) from e 375 break 376 377 resp = models.AccountAttachmentCreateResponse() 378 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 379 plumbing_response.account_attachment) 380 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 381 plumbing_response.meta) 382 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 383 plumbing_response.rate_limit) 384 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
386 def get(self, id, timeout=None): 387 ''' 388 Get reads one AccountAttachment by ID. 389 ''' 390 deadline = None if timeout is None else time.time() + timeout 391 req = AccountAttachmentGetRequest() 392 if self.parent.snapshot_datetime is not None: 393 req.meta.CopyFrom(GetRequestMetadata()) 394 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 395 396 req.id = (id) 397 tries = 0 398 plumbing_response = None 399 while True: 400 t = None if deadline is None else deadline - time.time() 401 try: 402 plumbing_response = self.stub.Get( 403 req, 404 metadata=self.parent.get_metadata('AccountAttachments.Get', 405 req), 406 timeout=t) 407 except Exception as e: 408 if self.parent.shouldRetry(tries, e, deadline): 409 tries += 1 410 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 411 continue 412 raise plumbing.convert_error_to_porcelain(e) from e 413 break 414 415 resp = models.AccountAttachmentGetResponse() 416 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 417 plumbing_response.account_attachment) 418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 419 plumbing_response.meta) 420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 421 plumbing_response.rate_limit) 422 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
424 def delete(self, id, timeout=None): 425 ''' 426 Delete removes a AccountAttachment by ID. 427 ''' 428 deadline = None if timeout is None else time.time() + timeout 429 req = AccountAttachmentDeleteRequest() 430 431 req.id = (id) 432 tries = 0 433 plumbing_response = None 434 while True: 435 t = None if deadline is None else deadline - time.time() 436 try: 437 plumbing_response = self.stub.Delete( 438 req, 439 metadata=self.parent.get_metadata( 440 'AccountAttachments.Delete', req), 441 timeout=t) 442 except Exception as e: 443 if self.parent.shouldRetry(tries, e, deadline): 444 tries += 1 445 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 446 continue 447 raise plumbing.convert_error_to_porcelain(e) from e 448 break 449 450 resp = models.AccountAttachmentDeleteResponse() 451 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 452 plumbing_response.meta) 453 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 454 plumbing_response.rate_limit) 455 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
457 def list(self, filter, *args, timeout=None): 458 ''' 459 List gets a list of AccountAttachments matching a given set of criteria. 460 ''' 461 deadline = None if timeout is None else time.time() + timeout 462 req = AccountAttachmentListRequest() 463 req.meta.CopyFrom(ListRequestMetadata()) 464 if self.parent.page_limit > 0: 465 req.meta.limit = self.parent.page_limit 466 if self.parent.snapshot_datetime is not None: 467 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 468 469 req.filter = plumbing.quote_filter_args(filter, *args) 470 471 def generator(svc, req): 472 tries = 0 473 while True: 474 t = None if deadline is None else deadline - time.time() 475 try: 476 plumbing_response = svc.stub.List( 477 req, 478 metadata=svc.parent.get_metadata( 479 'AccountAttachments.List', req), 480 timeout=t) 481 except Exception as e: 482 if self.parent.shouldRetry(tries, e, deadline): 483 tries += 1 484 time.sleep( 485 self.parent.exponentialBackoff(tries, deadline)) 486 continue 487 raise plumbing.convert_error_to_porcelain(e) from e 488 tries = 0 489 for plumbing_item in plumbing_response.account_attachments: 490 yield plumbing.convert_account_attachment_to_porcelain( 491 plumbing_item) 492 if plumbing_response.meta.next_cursor == '': 493 break 494 req.meta.cursor = plumbing_response.meta.next_cursor 495 496 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
499class SnapshotAccountAttachments: 500 ''' 501 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 502 service for historical queries. 503 ''' 504 def __init__(self, account_attachments): 505 self.account_attachments = account_attachments 506 507 def get(self, id, timeout=None): 508 ''' 509 Get reads one AccountAttachment by ID. 510 ''' 511 return self.account_attachments.get(id, timeout=timeout) 512 513 def list(self, filter, *args, timeout=None): 514 ''' 515 List gets a list of AccountAttachments matching a given set of criteria. 516 ''' 517 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)
507 def get(self, id, timeout=None): 508 ''' 509 Get reads one AccountAttachment by ID. 510 ''' 511 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
513 def list(self, filter, *args, timeout=None): 514 ''' 515 List gets a list of AccountAttachments matching a given set of criteria. 516 ''' 517 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
520class AccountAttachmentsHistory: 521 ''' 522 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 523 See `strongdm.models.AccountAttachmentHistory`. 524 ''' 525 def __init__(self, channel, client): 526 self.parent = client 527 self.stub = AccountAttachmentsHistoryStub(channel) 528 529 def list(self, filter, *args, timeout=None): 530 ''' 531 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 532 ''' 533 deadline = None if timeout is None else time.time() + timeout 534 req = AccountAttachmentHistoryListRequest() 535 req.meta.CopyFrom(ListRequestMetadata()) 536 if self.parent.page_limit > 0: 537 req.meta.limit = self.parent.page_limit 538 if self.parent.snapshot_datetime is not None: 539 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 540 541 req.filter = plumbing.quote_filter_args(filter, *args) 542 543 def generator(svc, req): 544 tries = 0 545 while True: 546 t = None if deadline is None else deadline - time.time() 547 try: 548 plumbing_response = svc.stub.List( 549 req, 550 metadata=svc.parent.get_metadata( 551 'AccountAttachmentsHistory.List', req), 552 timeout=t) 553 except Exception as e: 554 if self.parent.shouldRetry(tries, e, deadline): 555 tries += 1 556 time.sleep( 557 self.parent.exponentialBackoff(tries, deadline)) 558 continue 559 raise plumbing.convert_error_to_porcelain(e) from e 560 tries = 0 561 for plumbing_item in plumbing_response.history: 562 yield plumbing.convert_account_attachment_history_to_porcelain( 563 plumbing_item) 564 if plumbing_response.meta.next_cursor == '': 565 break 566 req.meta.cursor = plumbing_response.meta.next_cursor 567 568 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)
529 def list(self, filter, *args, timeout=None): 530 ''' 531 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 532 ''' 533 deadline = None if timeout is None else time.time() + timeout 534 req = AccountAttachmentHistoryListRequest() 535 req.meta.CopyFrom(ListRequestMetadata()) 536 if self.parent.page_limit > 0: 537 req.meta.limit = self.parent.page_limit 538 if self.parent.snapshot_datetime is not None: 539 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 540 541 req.filter = plumbing.quote_filter_args(filter, *args) 542 543 def generator(svc, req): 544 tries = 0 545 while True: 546 t = None if deadline is None else deadline - time.time() 547 try: 548 plumbing_response = svc.stub.List( 549 req, 550 metadata=svc.parent.get_metadata( 551 'AccountAttachmentsHistory.List', req), 552 timeout=t) 553 except Exception as e: 554 if self.parent.shouldRetry(tries, e, deadline): 555 tries += 1 556 time.sleep( 557 self.parent.exponentialBackoff(tries, deadline)) 558 continue 559 raise plumbing.convert_error_to_porcelain(e) from e 560 tries = 0 561 for plumbing_item in plumbing_response.history: 562 yield plumbing.convert_account_attachment_history_to_porcelain( 563 plumbing_item) 564 if plumbing_response.meta.next_cursor == '': 565 break 566 req.meta.cursor = plumbing_response.meta.next_cursor 567 568 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
571class AccountGrants: 572 ''' 573 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 574 See `strongdm.models.AccountGrant`. 575 ''' 576 def __init__(self, channel, client): 577 self.parent = client 578 self.stub = AccountGrantsStub(channel) 579 580 def create(self, account_grant, timeout=None): 581 ''' 582 Create registers a new AccountGrant. 583 ''' 584 deadline = None if timeout is None else time.time() + timeout 585 req = AccountGrantCreateRequest() 586 587 if account_grant is not None: 588 req.account_grant.CopyFrom( 589 plumbing.convert_account_grant_to_plumbing(account_grant)) 590 tries = 0 591 plumbing_response = None 592 while True: 593 t = None if deadline is None else deadline - time.time() 594 try: 595 plumbing_response = self.stub.Create( 596 req, 597 metadata=self.parent.get_metadata('AccountGrants.Create', 598 req), 599 timeout=t) 600 except Exception as e: 601 if self.parent.shouldRetry(tries, e, deadline): 602 tries += 1 603 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 604 continue 605 raise plumbing.convert_error_to_porcelain(e) from e 606 break 607 608 resp = models.AccountGrantCreateResponse() 609 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 610 plumbing_response.account_grant) 611 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 612 plumbing_response.meta) 613 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 614 plumbing_response.rate_limit) 615 return resp 616 617 def get(self, id, timeout=None): 618 ''' 619 Get reads one AccountGrant by ID. 620 ''' 621 deadline = None if timeout is None else time.time() + timeout 622 req = AccountGrantGetRequest() 623 if self.parent.snapshot_datetime is not None: 624 req.meta.CopyFrom(GetRequestMetadata()) 625 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 626 627 req.id = (id) 628 tries = 0 629 plumbing_response = None 630 while True: 631 t = None if deadline is None else deadline - time.time() 632 try: 633 plumbing_response = self.stub.Get( 634 req, 635 metadata=self.parent.get_metadata('AccountGrants.Get', 636 req), 637 timeout=t) 638 except Exception as e: 639 if self.parent.shouldRetry(tries, e, deadline): 640 tries += 1 641 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 642 continue 643 raise plumbing.convert_error_to_porcelain(e) from e 644 break 645 646 resp = models.AccountGrantGetResponse() 647 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 648 plumbing_response.account_grant) 649 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 650 plumbing_response.meta) 651 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 652 plumbing_response.rate_limit) 653 return resp 654 655 def delete(self, id, timeout=None): 656 ''' 657 Delete removes a AccountGrant by ID. 658 ''' 659 deadline = None if timeout is None else time.time() + timeout 660 req = AccountGrantDeleteRequest() 661 662 req.id = (id) 663 tries = 0 664 plumbing_response = None 665 while True: 666 t = None if deadline is None else deadline - time.time() 667 try: 668 plumbing_response = self.stub.Delete( 669 req, 670 metadata=self.parent.get_metadata('AccountGrants.Delete', 671 req), 672 timeout=t) 673 except Exception as e: 674 if self.parent.shouldRetry(tries, e, deadline): 675 tries += 1 676 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 677 continue 678 raise plumbing.convert_error_to_porcelain(e) from e 679 break 680 681 resp = models.AccountGrantDeleteResponse() 682 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 683 plumbing_response.meta) 684 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 685 plumbing_response.rate_limit) 686 return resp 687 688 def list(self, filter, *args, timeout=None): 689 ''' 690 List gets a list of AccountGrants matching a given set of criteria. 691 ''' 692 deadline = None if timeout is None else time.time() + timeout 693 req = AccountGrantListRequest() 694 req.meta.CopyFrom(ListRequestMetadata()) 695 if self.parent.page_limit > 0: 696 req.meta.limit = self.parent.page_limit 697 if self.parent.snapshot_datetime is not None: 698 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 699 700 req.filter = plumbing.quote_filter_args(filter, *args) 701 702 def generator(svc, req): 703 tries = 0 704 while True: 705 t = None if deadline is None else deadline - time.time() 706 try: 707 plumbing_response = svc.stub.List( 708 req, 709 metadata=svc.parent.get_metadata( 710 'AccountGrants.List', req), 711 timeout=t) 712 except Exception as e: 713 if self.parent.shouldRetry(tries, e, deadline): 714 tries += 1 715 time.sleep( 716 self.parent.exponentialBackoff(tries, deadline)) 717 continue 718 raise plumbing.convert_error_to_porcelain(e) from e 719 tries = 0 720 for plumbing_item in plumbing_response.account_grants: 721 yield plumbing.convert_account_grant_to_porcelain( 722 plumbing_item) 723 if plumbing_response.meta.next_cursor == '': 724 break 725 req.meta.cursor = plumbing_response.meta.next_cursor 726 727 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)
580 def create(self, account_grant, timeout=None): 581 ''' 582 Create registers a new AccountGrant. 583 ''' 584 deadline = None if timeout is None else time.time() + timeout 585 req = AccountGrantCreateRequest() 586 587 if account_grant is not None: 588 req.account_grant.CopyFrom( 589 plumbing.convert_account_grant_to_plumbing(account_grant)) 590 tries = 0 591 plumbing_response = None 592 while True: 593 t = None if deadline is None else deadline - time.time() 594 try: 595 plumbing_response = self.stub.Create( 596 req, 597 metadata=self.parent.get_metadata('AccountGrants.Create', 598 req), 599 timeout=t) 600 except Exception as e: 601 if self.parent.shouldRetry(tries, e, deadline): 602 tries += 1 603 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 604 continue 605 raise plumbing.convert_error_to_porcelain(e) from e 606 break 607 608 resp = models.AccountGrantCreateResponse() 609 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 610 plumbing_response.account_grant) 611 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 612 plumbing_response.meta) 613 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 614 plumbing_response.rate_limit) 615 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
617 def get(self, id, timeout=None): 618 ''' 619 Get reads one AccountGrant by ID. 620 ''' 621 deadline = None if timeout is None else time.time() + timeout 622 req = AccountGrantGetRequest() 623 if self.parent.snapshot_datetime is not None: 624 req.meta.CopyFrom(GetRequestMetadata()) 625 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 626 627 req.id = (id) 628 tries = 0 629 plumbing_response = None 630 while True: 631 t = None if deadline is None else deadline - time.time() 632 try: 633 plumbing_response = self.stub.Get( 634 req, 635 metadata=self.parent.get_metadata('AccountGrants.Get', 636 req), 637 timeout=t) 638 except Exception as e: 639 if self.parent.shouldRetry(tries, e, deadline): 640 tries += 1 641 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 642 continue 643 raise plumbing.convert_error_to_porcelain(e) from e 644 break 645 646 resp = models.AccountGrantGetResponse() 647 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 648 plumbing_response.account_grant) 649 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 650 plumbing_response.meta) 651 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 652 plumbing_response.rate_limit) 653 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
655 def delete(self, id, timeout=None): 656 ''' 657 Delete removes a AccountGrant by ID. 658 ''' 659 deadline = None if timeout is None else time.time() + timeout 660 req = AccountGrantDeleteRequest() 661 662 req.id = (id) 663 tries = 0 664 plumbing_response = None 665 while True: 666 t = None if deadline is None else deadline - time.time() 667 try: 668 plumbing_response = self.stub.Delete( 669 req, 670 metadata=self.parent.get_metadata('AccountGrants.Delete', 671 req), 672 timeout=t) 673 except Exception as e: 674 if self.parent.shouldRetry(tries, e, deadline): 675 tries += 1 676 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 677 continue 678 raise plumbing.convert_error_to_porcelain(e) from e 679 break 680 681 resp = models.AccountGrantDeleteResponse() 682 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 683 plumbing_response.meta) 684 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 685 plumbing_response.rate_limit) 686 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
688 def list(self, filter, *args, timeout=None): 689 ''' 690 List gets a list of AccountGrants matching a given set of criteria. 691 ''' 692 deadline = None if timeout is None else time.time() + timeout 693 req = AccountGrantListRequest() 694 req.meta.CopyFrom(ListRequestMetadata()) 695 if self.parent.page_limit > 0: 696 req.meta.limit = self.parent.page_limit 697 if self.parent.snapshot_datetime is not None: 698 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 699 700 req.filter = plumbing.quote_filter_args(filter, *args) 701 702 def generator(svc, req): 703 tries = 0 704 while True: 705 t = None if deadline is None else deadline - time.time() 706 try: 707 plumbing_response = svc.stub.List( 708 req, 709 metadata=svc.parent.get_metadata( 710 'AccountGrants.List', req), 711 timeout=t) 712 except Exception as e: 713 if self.parent.shouldRetry(tries, e, deadline): 714 tries += 1 715 time.sleep( 716 self.parent.exponentialBackoff(tries, deadline)) 717 continue 718 raise plumbing.convert_error_to_porcelain(e) from e 719 tries = 0 720 for plumbing_item in plumbing_response.account_grants: 721 yield plumbing.convert_account_grant_to_porcelain( 722 plumbing_item) 723 if plumbing_response.meta.next_cursor == '': 724 break 725 req.meta.cursor = plumbing_response.meta.next_cursor 726 727 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
730class SnapshotAccountGrants: 731 ''' 732 SnapshotAccountGrants exposes the read only methods of the AccountGrants 733 service for historical queries. 734 ''' 735 def __init__(self, account_grants): 736 self.account_grants = account_grants 737 738 def get(self, id, timeout=None): 739 ''' 740 Get reads one AccountGrant by ID. 741 ''' 742 return self.account_grants.get(id, timeout=timeout) 743 744 def list(self, filter, *args, timeout=None): 745 ''' 746 List gets a list of AccountGrants matching a given set of criteria. 747 ''' 748 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)
738 def get(self, id, timeout=None): 739 ''' 740 Get reads one AccountGrant by ID. 741 ''' 742 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
744 def list(self, filter, *args, timeout=None): 745 ''' 746 List gets a list of AccountGrants matching a given set of criteria. 747 ''' 748 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
751class AccountGrantsHistory: 752 ''' 753 AccountGrantsHistory records all changes to the state of an AccountGrant. 754 See `strongdm.models.AccountGrantHistory`. 755 ''' 756 def __init__(self, channel, client): 757 self.parent = client 758 self.stub = AccountGrantsHistoryStub(channel) 759 760 def list(self, filter, *args, timeout=None): 761 ''' 762 List gets a list of AccountGrantHistory records matching a given set of criteria. 763 ''' 764 deadline = None if timeout is None else time.time() + timeout 765 req = AccountGrantHistoryListRequest() 766 req.meta.CopyFrom(ListRequestMetadata()) 767 if self.parent.page_limit > 0: 768 req.meta.limit = self.parent.page_limit 769 if self.parent.snapshot_datetime is not None: 770 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 771 772 req.filter = plumbing.quote_filter_args(filter, *args) 773 774 def generator(svc, req): 775 tries = 0 776 while True: 777 t = None if deadline is None else deadline - time.time() 778 try: 779 plumbing_response = svc.stub.List( 780 req, 781 metadata=svc.parent.get_metadata( 782 'AccountGrantsHistory.List', req), 783 timeout=t) 784 except Exception as e: 785 if self.parent.shouldRetry(tries, e, deadline): 786 tries += 1 787 time.sleep( 788 self.parent.exponentialBackoff(tries, deadline)) 789 continue 790 raise plumbing.convert_error_to_porcelain(e) from e 791 tries = 0 792 for plumbing_item in plumbing_response.history: 793 yield plumbing.convert_account_grant_history_to_porcelain( 794 plumbing_item) 795 if plumbing_response.meta.next_cursor == '': 796 break 797 req.meta.cursor = plumbing_response.meta.next_cursor 798 799 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)
760 def list(self, filter, *args, timeout=None): 761 ''' 762 List gets a list of AccountGrantHistory records matching a given set of criteria. 763 ''' 764 deadline = None if timeout is None else time.time() + timeout 765 req = AccountGrantHistoryListRequest() 766 req.meta.CopyFrom(ListRequestMetadata()) 767 if self.parent.page_limit > 0: 768 req.meta.limit = self.parent.page_limit 769 if self.parent.snapshot_datetime is not None: 770 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 771 772 req.filter = plumbing.quote_filter_args(filter, *args) 773 774 def generator(svc, req): 775 tries = 0 776 while True: 777 t = None if deadline is None else deadline - time.time() 778 try: 779 plumbing_response = svc.stub.List( 780 req, 781 metadata=svc.parent.get_metadata( 782 'AccountGrantsHistory.List', req), 783 timeout=t) 784 except Exception as e: 785 if self.parent.shouldRetry(tries, e, deadline): 786 tries += 1 787 time.sleep( 788 self.parent.exponentialBackoff(tries, deadline)) 789 continue 790 raise plumbing.convert_error_to_porcelain(e) from e 791 tries = 0 792 for plumbing_item in plumbing_response.history: 793 yield plumbing.convert_account_grant_history_to_porcelain( 794 plumbing_item) 795 if plumbing_response.meta.next_cursor == '': 796 break 797 req.meta.cursor = plumbing_response.meta.next_cursor 798 799 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
802class AccountPermissions: 803 ''' 804 AccountPermissions records the granular permissions accounts have, allowing them to execute 805 relevant commands via StrongDM's APIs. 806 See `strongdm.models.AccountPermission`. 807 ''' 808 def __init__(self, channel, client): 809 self.parent = client 810 self.stub = AccountPermissionsStub(channel) 811 812 def list(self, filter, *args, timeout=None): 813 ''' 814 List gets a list of Permission records matching a given set of criteria. 815 ''' 816 deadline = None if timeout is None else time.time() + timeout 817 req = AccountPermissionListRequest() 818 req.meta.CopyFrom(ListRequestMetadata()) 819 if self.parent.page_limit > 0: 820 req.meta.limit = self.parent.page_limit 821 if self.parent.snapshot_datetime is not None: 822 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 823 824 req.filter = plumbing.quote_filter_args(filter, *args) 825 826 def generator(svc, req): 827 tries = 0 828 while True: 829 t = None if deadline is None else deadline - time.time() 830 try: 831 plumbing_response = svc.stub.List( 832 req, 833 metadata=svc.parent.get_metadata( 834 'AccountPermissions.List', req), 835 timeout=t) 836 except Exception as e: 837 if self.parent.shouldRetry(tries, e, deadline): 838 tries += 1 839 time.sleep( 840 self.parent.exponentialBackoff(tries, deadline)) 841 continue 842 raise plumbing.convert_error_to_porcelain(e) from e 843 tries = 0 844 for plumbing_item in plumbing_response.permissions: 845 yield plumbing.convert_account_permission_to_porcelain( 846 plumbing_item) 847 if plumbing_response.meta.next_cursor == '': 848 break 849 req.meta.cursor = plumbing_response.meta.next_cursor 850 851 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)
812 def list(self, filter, *args, timeout=None): 813 ''' 814 List gets a list of Permission records matching a given set of criteria. 815 ''' 816 deadline = None if timeout is None else time.time() + timeout 817 req = AccountPermissionListRequest() 818 req.meta.CopyFrom(ListRequestMetadata()) 819 if self.parent.page_limit > 0: 820 req.meta.limit = self.parent.page_limit 821 if self.parent.snapshot_datetime is not None: 822 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 823 824 req.filter = plumbing.quote_filter_args(filter, *args) 825 826 def generator(svc, req): 827 tries = 0 828 while True: 829 t = None if deadline is None else deadline - time.time() 830 try: 831 plumbing_response = svc.stub.List( 832 req, 833 metadata=svc.parent.get_metadata( 834 'AccountPermissions.List', req), 835 timeout=t) 836 except Exception as e: 837 if self.parent.shouldRetry(tries, e, deadline): 838 tries += 1 839 time.sleep( 840 self.parent.exponentialBackoff(tries, deadline)) 841 continue 842 raise plumbing.convert_error_to_porcelain(e) from e 843 tries = 0 844 for plumbing_item in plumbing_response.permissions: 845 yield plumbing.convert_account_permission_to_porcelain( 846 plumbing_item) 847 if plumbing_response.meta.next_cursor == '': 848 break 849 req.meta.cursor = plumbing_response.meta.next_cursor 850 851 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
854class SnapshotAccountPermissions: 855 ''' 856 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 857 service for historical queries. 858 ''' 859 def __init__(self, account_permissions): 860 self.account_permissions = account_permissions 861 862 def list(self, filter, *args, timeout=None): 863 ''' 864 List gets a list of Permission records matching a given set of criteria. 865 ''' 866 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)
862 def list(self, filter, *args, timeout=None): 863 ''' 864 List gets a list of Permission records matching a given set of criteria. 865 ''' 866 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
869class AccountResources: 870 ''' 871 AccountResources enumerates the resources to which accounts have access. 872 The AccountResources service is read-only. 873 See `strongdm.models.AccountResource`. 874 ''' 875 def __init__(self, channel, client): 876 self.parent = client 877 self.stub = AccountResourcesStub(channel) 878 879 def list(self, filter, *args, timeout=None): 880 ''' 881 List gets a list of AccountResource records matching a given set of criteria. 882 ''' 883 deadline = None if timeout is None else time.time() + timeout 884 req = AccountResourceListRequest() 885 req.meta.CopyFrom(ListRequestMetadata()) 886 if self.parent.page_limit > 0: 887 req.meta.limit = self.parent.page_limit 888 if self.parent.snapshot_datetime is not None: 889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 890 891 req.filter = plumbing.quote_filter_args(filter, *args) 892 893 def generator(svc, req): 894 tries = 0 895 while True: 896 t = None if deadline is None else deadline - time.time() 897 try: 898 plumbing_response = svc.stub.List( 899 req, 900 metadata=svc.parent.get_metadata( 901 'AccountResources.List', req), 902 timeout=t) 903 except Exception as e: 904 if self.parent.shouldRetry(tries, e, deadline): 905 tries += 1 906 time.sleep( 907 self.parent.exponentialBackoff(tries, deadline)) 908 continue 909 raise plumbing.convert_error_to_porcelain(e) from e 910 tries = 0 911 for plumbing_item in plumbing_response.account_resources: 912 yield plumbing.convert_account_resource_to_porcelain( 913 plumbing_item) 914 if plumbing_response.meta.next_cursor == '': 915 break 916 req.meta.cursor = plumbing_response.meta.next_cursor 917 918 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)
879 def list(self, filter, *args, timeout=None): 880 ''' 881 List gets a list of AccountResource records matching a given set of criteria. 882 ''' 883 deadline = None if timeout is None else time.time() + timeout 884 req = AccountResourceListRequest() 885 req.meta.CopyFrom(ListRequestMetadata()) 886 if self.parent.page_limit > 0: 887 req.meta.limit = self.parent.page_limit 888 if self.parent.snapshot_datetime is not None: 889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 890 891 req.filter = plumbing.quote_filter_args(filter, *args) 892 893 def generator(svc, req): 894 tries = 0 895 while True: 896 t = None if deadline is None else deadline - time.time() 897 try: 898 plumbing_response = svc.stub.List( 899 req, 900 metadata=svc.parent.get_metadata( 901 'AccountResources.List', req), 902 timeout=t) 903 except Exception as e: 904 if self.parent.shouldRetry(tries, e, deadline): 905 tries += 1 906 time.sleep( 907 self.parent.exponentialBackoff(tries, deadline)) 908 continue 909 raise plumbing.convert_error_to_porcelain(e) from e 910 tries = 0 911 for plumbing_item in plumbing_response.account_resources: 912 yield plumbing.convert_account_resource_to_porcelain( 913 plumbing_item) 914 if plumbing_response.meta.next_cursor == '': 915 break 916 req.meta.cursor = plumbing_response.meta.next_cursor 917 918 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
921class SnapshotAccountResources: 922 ''' 923 SnapshotAccountResources exposes the read only methods of the AccountResources 924 service for historical queries. 925 ''' 926 def __init__(self, account_resources): 927 self.account_resources = account_resources 928 929 def list(self, filter, *args, timeout=None): 930 ''' 931 List gets a list of AccountResource records matching a given set of criteria. 932 ''' 933 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)
929 def list(self, filter, *args, timeout=None): 930 ''' 931 List gets a list of AccountResource records matching a given set of criteria. 932 ''' 933 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
936class AccountResourcesHistory: 937 ''' 938 AccountResourcesHistory records all changes to the state of a AccountResource. 939 See `strongdm.models.AccountResourceHistory`. 940 ''' 941 def __init__(self, channel, client): 942 self.parent = client 943 self.stub = AccountResourcesHistoryStub(channel) 944 945 def list(self, filter, *args, timeout=None): 946 ''' 947 List gets a list of AccountResourceHistory records matching a given set of criteria. 948 ''' 949 deadline = None if timeout is None else time.time() + timeout 950 req = AccountResourceHistoryListRequest() 951 req.meta.CopyFrom(ListRequestMetadata()) 952 if self.parent.page_limit > 0: 953 req.meta.limit = self.parent.page_limit 954 if self.parent.snapshot_datetime is not None: 955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 956 957 req.filter = plumbing.quote_filter_args(filter, *args) 958 959 def generator(svc, req): 960 tries = 0 961 while True: 962 t = None if deadline is None else deadline - time.time() 963 try: 964 plumbing_response = svc.stub.List( 965 req, 966 metadata=svc.parent.get_metadata( 967 'AccountResourcesHistory.List', req), 968 timeout=t) 969 except Exception as e: 970 if self.parent.shouldRetry(tries, e, deadline): 971 tries += 1 972 time.sleep( 973 self.parent.exponentialBackoff(tries, deadline)) 974 continue 975 raise plumbing.convert_error_to_porcelain(e) from e 976 tries = 0 977 for plumbing_item in plumbing_response.history: 978 yield plumbing.convert_account_resource_history_to_porcelain( 979 plumbing_item) 980 if plumbing_response.meta.next_cursor == '': 981 break 982 req.meta.cursor = plumbing_response.meta.next_cursor 983 984 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)
945 def list(self, filter, *args, timeout=None): 946 ''' 947 List gets a list of AccountResourceHistory records matching a given set of criteria. 948 ''' 949 deadline = None if timeout is None else time.time() + timeout 950 req = AccountResourceHistoryListRequest() 951 req.meta.CopyFrom(ListRequestMetadata()) 952 if self.parent.page_limit > 0: 953 req.meta.limit = self.parent.page_limit 954 if self.parent.snapshot_datetime is not None: 955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 956 957 req.filter = plumbing.quote_filter_args(filter, *args) 958 959 def generator(svc, req): 960 tries = 0 961 while True: 962 t = None if deadline is None else deadline - time.time() 963 try: 964 plumbing_response = svc.stub.List( 965 req, 966 metadata=svc.parent.get_metadata( 967 'AccountResourcesHistory.List', req), 968 timeout=t) 969 except Exception as e: 970 if self.parent.shouldRetry(tries, e, deadline): 971 tries += 1 972 time.sleep( 973 self.parent.exponentialBackoff(tries, deadline)) 974 continue 975 raise plumbing.convert_error_to_porcelain(e) from e 976 tries = 0 977 for plumbing_item in plumbing_response.history: 978 yield plumbing.convert_account_resource_history_to_porcelain( 979 plumbing_item) 980 if plumbing_response.meta.next_cursor == '': 981 break 982 req.meta.cursor = plumbing_response.meta.next_cursor 983 984 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
987class Accounts: 988 ''' 989 Accounts are users that have access to strongDM. There are two types of accounts: 990 1. **Users:** humans who are authenticated through username and password or SSO. 991 2. **Service Accounts:** machines that are authenticated using a service token. 992 3. **Tokens** are access keys with permissions that can be used for authentication. 993 See: 994 `strongdm.models.Service` 995 `strongdm.models.Token` 996 `strongdm.models.User` 997 ''' 998 def __init__(self, channel, client): 999 self.parent = client 1000 self.stub = AccountsStub(channel) 1001 1002 def create(self, account, timeout=None): 1003 ''' 1004 Create registers a new Account. 1005 ''' 1006 deadline = None if timeout is None else time.time() + timeout 1007 req = AccountCreateRequest() 1008 1009 if account is not None: 1010 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1011 tries = 0 1012 plumbing_response = None 1013 while True: 1014 t = None if deadline is None else deadline - time.time() 1015 try: 1016 plumbing_response = self.stub.Create( 1017 req, 1018 metadata=self.parent.get_metadata('Accounts.Create', req), 1019 timeout=t) 1020 except Exception as e: 1021 if self.parent.shouldRetry(tries, e, deadline): 1022 tries += 1 1023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1024 continue 1025 raise plumbing.convert_error_to_porcelain(e) from e 1026 break 1027 1028 resp = models.AccountCreateResponse() 1029 resp.access_key = (plumbing_response.access_key) 1030 resp.account = plumbing.convert_account_to_porcelain( 1031 plumbing_response.account) 1032 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1033 plumbing_response.meta) 1034 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1035 plumbing_response.rate_limit) 1036 resp.secret_key = (plumbing_response.secret_key) 1037 resp.token = (plumbing_response.token) 1038 return resp 1039 1040 def get(self, id, timeout=None): 1041 ''' 1042 Get reads one Account by ID. 1043 ''' 1044 deadline = None if timeout is None else time.time() + timeout 1045 req = AccountGetRequest() 1046 if self.parent.snapshot_datetime is not None: 1047 req.meta.CopyFrom(GetRequestMetadata()) 1048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1049 1050 req.id = (id) 1051 tries = 0 1052 plumbing_response = None 1053 while True: 1054 t = None if deadline is None else deadline - time.time() 1055 try: 1056 plumbing_response = self.stub.Get( 1057 req, 1058 metadata=self.parent.get_metadata('Accounts.Get', req), 1059 timeout=t) 1060 except Exception as e: 1061 if self.parent.shouldRetry(tries, e, deadline): 1062 tries += 1 1063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1064 continue 1065 raise plumbing.convert_error_to_porcelain(e) from e 1066 break 1067 1068 resp = models.AccountGetResponse() 1069 resp.account = plumbing.convert_account_to_porcelain( 1070 plumbing_response.account) 1071 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1072 plumbing_response.meta) 1073 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1074 plumbing_response.rate_limit) 1075 return resp 1076 1077 def update(self, account, timeout=None): 1078 ''' 1079 Update replaces all the fields of an Account by ID. 1080 ''' 1081 deadline = None if timeout is None else time.time() + timeout 1082 req = AccountUpdateRequest() 1083 1084 if account is not None: 1085 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1086 tries = 0 1087 plumbing_response = None 1088 while True: 1089 t = None if deadline is None else deadline - time.time() 1090 try: 1091 plumbing_response = self.stub.Update( 1092 req, 1093 metadata=self.parent.get_metadata('Accounts.Update', req), 1094 timeout=t) 1095 except Exception as e: 1096 if self.parent.shouldRetry(tries, e, deadline): 1097 tries += 1 1098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1099 continue 1100 raise plumbing.convert_error_to_porcelain(e) from e 1101 break 1102 1103 resp = models.AccountUpdateResponse() 1104 resp.account = plumbing.convert_account_to_porcelain( 1105 plumbing_response.account) 1106 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1107 plumbing_response.meta) 1108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1109 plumbing_response.rate_limit) 1110 return resp 1111 1112 def delete(self, id, timeout=None): 1113 ''' 1114 Delete removes an Account by ID. 1115 ''' 1116 deadline = None if timeout is None else time.time() + timeout 1117 req = AccountDeleteRequest() 1118 1119 req.id = (id) 1120 tries = 0 1121 plumbing_response = None 1122 while True: 1123 t = None if deadline is None else deadline - time.time() 1124 try: 1125 plumbing_response = self.stub.Delete( 1126 req, 1127 metadata=self.parent.get_metadata('Accounts.Delete', req), 1128 timeout=t) 1129 except Exception as e: 1130 if self.parent.shouldRetry(tries, e, deadline): 1131 tries += 1 1132 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1133 continue 1134 raise plumbing.convert_error_to_porcelain(e) from e 1135 break 1136 1137 resp = models.AccountDeleteResponse() 1138 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1139 plumbing_response.meta) 1140 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1141 plumbing_response.rate_limit) 1142 return resp 1143 1144 def list(self, filter, *args, timeout=None): 1145 ''' 1146 List gets a list of Accounts matching a given set of criteria. 1147 ''' 1148 deadline = None if timeout is None else time.time() + timeout 1149 req = AccountListRequest() 1150 req.meta.CopyFrom(ListRequestMetadata()) 1151 if self.parent.page_limit > 0: 1152 req.meta.limit = self.parent.page_limit 1153 if self.parent.snapshot_datetime is not None: 1154 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1155 1156 req.filter = plumbing.quote_filter_args(filter, *args) 1157 1158 def generator(svc, req): 1159 tries = 0 1160 while True: 1161 t = None if deadline is None else deadline - time.time() 1162 try: 1163 plumbing_response = svc.stub.List( 1164 req, 1165 metadata=svc.parent.get_metadata('Accounts.List', req), 1166 timeout=t) 1167 except Exception as e: 1168 if self.parent.shouldRetry(tries, e, deadline): 1169 tries += 1 1170 time.sleep( 1171 self.parent.exponentialBackoff(tries, deadline)) 1172 continue 1173 raise plumbing.convert_error_to_porcelain(e) from e 1174 tries = 0 1175 for plumbing_item in plumbing_response.accounts: 1176 yield plumbing.convert_account_to_porcelain(plumbing_item) 1177 if plumbing_response.meta.next_cursor == '': 1178 break 1179 req.meta.cursor = plumbing_response.meta.next_cursor 1180 1181 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)
1002 def create(self, account, timeout=None): 1003 ''' 1004 Create registers a new Account. 1005 ''' 1006 deadline = None if timeout is None else time.time() + timeout 1007 req = AccountCreateRequest() 1008 1009 if account is not None: 1010 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1011 tries = 0 1012 plumbing_response = None 1013 while True: 1014 t = None if deadline is None else deadline - time.time() 1015 try: 1016 plumbing_response = self.stub.Create( 1017 req, 1018 metadata=self.parent.get_metadata('Accounts.Create', req), 1019 timeout=t) 1020 except Exception as e: 1021 if self.parent.shouldRetry(tries, e, deadline): 1022 tries += 1 1023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1024 continue 1025 raise plumbing.convert_error_to_porcelain(e) from e 1026 break 1027 1028 resp = models.AccountCreateResponse() 1029 resp.access_key = (plumbing_response.access_key) 1030 resp.account = plumbing.convert_account_to_porcelain( 1031 plumbing_response.account) 1032 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1033 plumbing_response.meta) 1034 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1035 plumbing_response.rate_limit) 1036 resp.secret_key = (plumbing_response.secret_key) 1037 resp.token = (plumbing_response.token) 1038 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1040 def get(self, id, timeout=None): 1041 ''' 1042 Get reads one Account by ID. 1043 ''' 1044 deadline = None if timeout is None else time.time() + timeout 1045 req = AccountGetRequest() 1046 if self.parent.snapshot_datetime is not None: 1047 req.meta.CopyFrom(GetRequestMetadata()) 1048 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1049 1050 req.id = (id) 1051 tries = 0 1052 plumbing_response = None 1053 while True: 1054 t = None if deadline is None else deadline - time.time() 1055 try: 1056 plumbing_response = self.stub.Get( 1057 req, 1058 metadata=self.parent.get_metadata('Accounts.Get', req), 1059 timeout=t) 1060 except Exception as e: 1061 if self.parent.shouldRetry(tries, e, deadline): 1062 tries += 1 1063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1064 continue 1065 raise plumbing.convert_error_to_porcelain(e) from e 1066 break 1067 1068 resp = models.AccountGetResponse() 1069 resp.account = plumbing.convert_account_to_porcelain( 1070 plumbing_response.account) 1071 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1072 plumbing_response.meta) 1073 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1074 plumbing_response.rate_limit) 1075 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1077 def update(self, account, timeout=None): 1078 ''' 1079 Update replaces all the fields of an Account by ID. 1080 ''' 1081 deadline = None if timeout is None else time.time() + timeout 1082 req = AccountUpdateRequest() 1083 1084 if account is not None: 1085 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1086 tries = 0 1087 plumbing_response = None 1088 while True: 1089 t = None if deadline is None else deadline - time.time() 1090 try: 1091 plumbing_response = self.stub.Update( 1092 req, 1093 metadata=self.parent.get_metadata('Accounts.Update', req), 1094 timeout=t) 1095 except Exception as e: 1096 if self.parent.shouldRetry(tries, e, deadline): 1097 tries += 1 1098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1099 continue 1100 raise plumbing.convert_error_to_porcelain(e) from e 1101 break 1102 1103 resp = models.AccountUpdateResponse() 1104 resp.account = plumbing.convert_account_to_porcelain( 1105 plumbing_response.account) 1106 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1107 plumbing_response.meta) 1108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1109 plumbing_response.rate_limit) 1110 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1112 def delete(self, id, timeout=None): 1113 ''' 1114 Delete removes an Account by ID. 1115 ''' 1116 deadline = None if timeout is None else time.time() + timeout 1117 req = AccountDeleteRequest() 1118 1119 req.id = (id) 1120 tries = 0 1121 plumbing_response = None 1122 while True: 1123 t = None if deadline is None else deadline - time.time() 1124 try: 1125 plumbing_response = self.stub.Delete( 1126 req, 1127 metadata=self.parent.get_metadata('Accounts.Delete', req), 1128 timeout=t) 1129 except Exception as e: 1130 if self.parent.shouldRetry(tries, e, deadline): 1131 tries += 1 1132 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1133 continue 1134 raise plumbing.convert_error_to_porcelain(e) from e 1135 break 1136 1137 resp = models.AccountDeleteResponse() 1138 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1139 plumbing_response.meta) 1140 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1141 plumbing_response.rate_limit) 1142 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1144 def list(self, filter, *args, timeout=None): 1145 ''' 1146 List gets a list of Accounts matching a given set of criteria. 1147 ''' 1148 deadline = None if timeout is None else time.time() + timeout 1149 req = AccountListRequest() 1150 req.meta.CopyFrom(ListRequestMetadata()) 1151 if self.parent.page_limit > 0: 1152 req.meta.limit = self.parent.page_limit 1153 if self.parent.snapshot_datetime is not None: 1154 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1155 1156 req.filter = plumbing.quote_filter_args(filter, *args) 1157 1158 def generator(svc, req): 1159 tries = 0 1160 while True: 1161 t = None if deadline is None else deadline - time.time() 1162 try: 1163 plumbing_response = svc.stub.List( 1164 req, 1165 metadata=svc.parent.get_metadata('Accounts.List', req), 1166 timeout=t) 1167 except Exception as e: 1168 if self.parent.shouldRetry(tries, e, deadline): 1169 tries += 1 1170 time.sleep( 1171 self.parent.exponentialBackoff(tries, deadline)) 1172 continue 1173 raise plumbing.convert_error_to_porcelain(e) from e 1174 tries = 0 1175 for plumbing_item in plumbing_response.accounts: 1176 yield plumbing.convert_account_to_porcelain(plumbing_item) 1177 if plumbing_response.meta.next_cursor == '': 1178 break 1179 req.meta.cursor = plumbing_response.meta.next_cursor 1180 1181 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1184class SnapshotAccounts: 1185 ''' 1186 SnapshotAccounts exposes the read only methods of the Accounts 1187 service for historical queries. 1188 ''' 1189 def __init__(self, accounts): 1190 self.accounts = accounts 1191 1192 def get(self, id, timeout=None): 1193 ''' 1194 Get reads one Account by ID. 1195 ''' 1196 return self.accounts.get(id, timeout=timeout) 1197 1198 def list(self, filter, *args, timeout=None): 1199 ''' 1200 List gets a list of Accounts matching a given set of criteria. 1201 ''' 1202 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)
1192 def get(self, id, timeout=None): 1193 ''' 1194 Get reads one Account by ID. 1195 ''' 1196 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1198 def list(self, filter, *args, timeout=None): 1199 ''' 1200 List gets a list of Accounts matching a given set of criteria. 1201 ''' 1202 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsHistory:
1205class AccountsHistory: 1206 ''' 1207 AccountsHistory records all changes to the state of an Account. 1208 See `strongdm.models.AccountHistory`. 1209 ''' 1210 def __init__(self, channel, client): 1211 self.parent = client 1212 self.stub = AccountsHistoryStub(channel) 1213 1214 def list(self, filter, *args, timeout=None): 1215 ''' 1216 List gets a list of AccountHistory records matching a given set of criteria. 1217 ''' 1218 deadline = None if timeout is None else time.time() + timeout 1219 req = AccountHistoryListRequest() 1220 req.meta.CopyFrom(ListRequestMetadata()) 1221 if self.parent.page_limit > 0: 1222 req.meta.limit = self.parent.page_limit 1223 if self.parent.snapshot_datetime is not None: 1224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1225 1226 req.filter = plumbing.quote_filter_args(filter, *args) 1227 1228 def generator(svc, req): 1229 tries = 0 1230 while True: 1231 t = None if deadline is None else deadline - time.time() 1232 try: 1233 plumbing_response = svc.stub.List( 1234 req, 1235 metadata=svc.parent.get_metadata( 1236 'AccountsHistory.List', req), 1237 timeout=t) 1238 except Exception as e: 1239 if self.parent.shouldRetry(tries, e, deadline): 1240 tries += 1 1241 time.sleep( 1242 self.parent.exponentialBackoff(tries, deadline)) 1243 continue 1244 raise plumbing.convert_error_to_porcelain(e) from e 1245 tries = 0 1246 for plumbing_item in plumbing_response.history: 1247 yield plumbing.convert_account_history_to_porcelain( 1248 plumbing_item) 1249 if plumbing_response.meta.next_cursor == '': 1250 break 1251 req.meta.cursor = plumbing_response.meta.next_cursor 1252 1253 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)
1214 def list(self, filter, *args, timeout=None): 1215 ''' 1216 List gets a list of AccountHistory records matching a given set of criteria. 1217 ''' 1218 deadline = None if timeout is None else time.time() + timeout 1219 req = AccountHistoryListRequest() 1220 req.meta.CopyFrom(ListRequestMetadata()) 1221 if self.parent.page_limit > 0: 1222 req.meta.limit = self.parent.page_limit 1223 if self.parent.snapshot_datetime is not None: 1224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1225 1226 req.filter = plumbing.quote_filter_args(filter, *args) 1227 1228 def generator(svc, req): 1229 tries = 0 1230 while True: 1231 t = None if deadline is None else deadline - time.time() 1232 try: 1233 plumbing_response = svc.stub.List( 1234 req, 1235 metadata=svc.parent.get_metadata( 1236 'AccountsHistory.List', req), 1237 timeout=t) 1238 except Exception as e: 1239 if self.parent.shouldRetry(tries, e, deadline): 1240 tries += 1 1241 time.sleep( 1242 self.parent.exponentialBackoff(tries, deadline)) 1243 continue 1244 raise plumbing.convert_error_to_porcelain(e) from e 1245 tries = 0 1246 for plumbing_item in plumbing_response.history: 1247 yield plumbing.convert_account_history_to_porcelain( 1248 plumbing_item) 1249 if plumbing_response.meta.next_cursor == '': 1250 break 1251 req.meta.cursor = plumbing_response.meta.next_cursor 1252 1253 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1256class Activities: 1257 ''' 1258 An Activity is a record of an action taken against a strongDM deployment, e.g. 1259 a user creation, resource deletion, sso configuration change, etc. The Activities 1260 service is read-only. 1261 See `strongdm.models.Activity`. 1262 ''' 1263 def __init__(self, channel, client): 1264 self.parent = client 1265 self.stub = ActivitiesStub(channel) 1266 1267 def get(self, id, timeout=None): 1268 ''' 1269 Get reads one Activity by ID. 1270 ''' 1271 deadline = None if timeout is None else time.time() + timeout 1272 req = ActivityGetRequest() 1273 if self.parent.snapshot_datetime is not None: 1274 req.meta.CopyFrom(GetRequestMetadata()) 1275 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1276 1277 req.id = (id) 1278 tries = 0 1279 plumbing_response = None 1280 while True: 1281 t = None if deadline is None else deadline - time.time() 1282 try: 1283 plumbing_response = self.stub.Get( 1284 req, 1285 metadata=self.parent.get_metadata('Activities.Get', req), 1286 timeout=t) 1287 except Exception as e: 1288 if self.parent.shouldRetry(tries, e, deadline): 1289 tries += 1 1290 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1291 continue 1292 raise plumbing.convert_error_to_porcelain(e) from e 1293 break 1294 1295 resp = models.ActivityGetResponse() 1296 resp.activity = plumbing.convert_activity_to_porcelain( 1297 plumbing_response.activity) 1298 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1299 plumbing_response.meta) 1300 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1301 plumbing_response.rate_limit) 1302 return resp 1303 1304 def list(self, filter, *args, timeout=None): 1305 ''' 1306 List gets a list of Activities matching a given set of criteria. 1307 The 'before' and 'after' filters can be used to control the time 1308 range of the output activities. If not provided, one week of back 1309 of activities will be returned. 1310 ''' 1311 deadline = None if timeout is None else time.time() + timeout 1312 req = ActivityListRequest() 1313 req.meta.CopyFrom(ListRequestMetadata()) 1314 if self.parent.page_limit > 0: 1315 req.meta.limit = self.parent.page_limit 1316 if self.parent.snapshot_datetime is not None: 1317 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1318 1319 req.filter = plumbing.quote_filter_args(filter, *args) 1320 1321 def generator(svc, req): 1322 tries = 0 1323 while True: 1324 t = None if deadline is None else deadline - time.time() 1325 try: 1326 plumbing_response = svc.stub.List( 1327 req, 1328 metadata=svc.parent.get_metadata( 1329 'Activities.List', req), 1330 timeout=t) 1331 except Exception as e: 1332 if self.parent.shouldRetry(tries, e, deadline): 1333 tries += 1 1334 time.sleep( 1335 self.parent.exponentialBackoff(tries, deadline)) 1336 continue 1337 raise plumbing.convert_error_to_porcelain(e) from e 1338 tries = 0 1339 for plumbing_item in plumbing_response.activities: 1340 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1341 if plumbing_response.meta.next_cursor == '': 1342 break 1343 req.meta.cursor = plumbing_response.meta.next_cursor 1344 1345 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)
1267 def get(self, id, timeout=None): 1268 ''' 1269 Get reads one Activity by ID. 1270 ''' 1271 deadline = None if timeout is None else time.time() + timeout 1272 req = ActivityGetRequest() 1273 if self.parent.snapshot_datetime is not None: 1274 req.meta.CopyFrom(GetRequestMetadata()) 1275 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1276 1277 req.id = (id) 1278 tries = 0 1279 plumbing_response = None 1280 while True: 1281 t = None if deadline is None else deadline - time.time() 1282 try: 1283 plumbing_response = self.stub.Get( 1284 req, 1285 metadata=self.parent.get_metadata('Activities.Get', req), 1286 timeout=t) 1287 except Exception as e: 1288 if self.parent.shouldRetry(tries, e, deadline): 1289 tries += 1 1290 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1291 continue 1292 raise plumbing.convert_error_to_porcelain(e) from e 1293 break 1294 1295 resp = models.ActivityGetResponse() 1296 resp.activity = plumbing.convert_activity_to_porcelain( 1297 plumbing_response.activity) 1298 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1299 plumbing_response.meta) 1300 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1301 plumbing_response.rate_limit) 1302 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1304 def list(self, filter, *args, timeout=None): 1305 ''' 1306 List gets a list of Activities matching a given set of criteria. 1307 The 'before' and 'after' filters can be used to control the time 1308 range of the output activities. If not provided, one week of back 1309 of activities will be returned. 1310 ''' 1311 deadline = None if timeout is None else time.time() + timeout 1312 req = ActivityListRequest() 1313 req.meta.CopyFrom(ListRequestMetadata()) 1314 if self.parent.page_limit > 0: 1315 req.meta.limit = self.parent.page_limit 1316 if self.parent.snapshot_datetime is not None: 1317 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1318 1319 req.filter = plumbing.quote_filter_args(filter, *args) 1320 1321 def generator(svc, req): 1322 tries = 0 1323 while True: 1324 t = None if deadline is None else deadline - time.time() 1325 try: 1326 plumbing_response = svc.stub.List( 1327 req, 1328 metadata=svc.parent.get_metadata( 1329 'Activities.List', req), 1330 timeout=t) 1331 except Exception as e: 1332 if self.parent.shouldRetry(tries, e, deadline): 1333 tries += 1 1334 time.sleep( 1335 self.parent.exponentialBackoff(tries, deadline)) 1336 continue 1337 raise plumbing.convert_error_to_porcelain(e) from e 1338 tries = 0 1339 for plumbing_item in plumbing_response.activities: 1340 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1341 if plumbing_response.meta.next_cursor == '': 1342 break 1343 req.meta.cursor = plumbing_response.meta.next_cursor 1344 1345 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:
1348class ApprovalWorkflowApprovers: 1349 ''' 1350 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1351 See `strongdm.models.ApprovalWorkflowApprover`. 1352 ''' 1353 def __init__(self, channel, client): 1354 self.parent = client 1355 self.stub = ApprovalWorkflowApproversStub(channel) 1356 1357 def create(self, approval_workflow_approver, timeout=None): 1358 ''' 1359 Deprecated: Create creates a new approval workflow approver. 1360 ''' 1361 deadline = None if timeout is None else time.time() + timeout 1362 req = ApprovalWorkflowApproverCreateRequest() 1363 1364 if approval_workflow_approver is not None: 1365 req.approval_workflow_approver.CopyFrom( 1366 plumbing.convert_approval_workflow_approver_to_plumbing( 1367 approval_workflow_approver)) 1368 tries = 0 1369 plumbing_response = None 1370 while True: 1371 t = None if deadline is None else deadline - time.time() 1372 try: 1373 plumbing_response = self.stub.Create( 1374 req, 1375 metadata=self.parent.get_metadata( 1376 'ApprovalWorkflowApprovers.Create', req), 1377 timeout=t) 1378 except Exception as e: 1379 if self.parent.shouldRetry(tries, e, deadline): 1380 tries += 1 1381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1382 continue 1383 raise plumbing.convert_error_to_porcelain(e) from e 1384 break 1385 1386 resp = models.ApprovalWorkflowApproverCreateResponse() 1387 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1388 plumbing_response.approval_workflow_approver) 1389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1390 plumbing_response.rate_limit) 1391 return resp 1392 1393 def get(self, id, timeout=None): 1394 ''' 1395 Deprecated: Get reads one approval workflow approver by ID. 1396 ''' 1397 deadline = None if timeout is None else time.time() + timeout 1398 req = ApprovalWorkflowApproverGetRequest() 1399 if self.parent.snapshot_datetime is not None: 1400 req.meta.CopyFrom(GetRequestMetadata()) 1401 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1402 1403 req.id = (id) 1404 tries = 0 1405 plumbing_response = None 1406 while True: 1407 t = None if deadline is None else deadline - time.time() 1408 try: 1409 plumbing_response = self.stub.Get( 1410 req, 1411 metadata=self.parent.get_metadata( 1412 'ApprovalWorkflowApprovers.Get', req), 1413 timeout=t) 1414 except Exception as e: 1415 if self.parent.shouldRetry(tries, e, deadline): 1416 tries += 1 1417 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1418 continue 1419 raise plumbing.convert_error_to_porcelain(e) from e 1420 break 1421 1422 resp = models.ApprovalWorkflowApproverGetResponse() 1423 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1424 plumbing_response.approval_workflow_approver) 1425 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1426 plumbing_response.meta) 1427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1428 plumbing_response.rate_limit) 1429 return resp 1430 1431 def delete(self, id, timeout=None): 1432 ''' 1433 Deprecated: Delete deletes an existing approval workflow approver. 1434 ''' 1435 deadline = None if timeout is None else time.time() + timeout 1436 req = ApprovalWorkflowApproverDeleteRequest() 1437 1438 req.id = (id) 1439 tries = 0 1440 plumbing_response = None 1441 while True: 1442 t = None if deadline is None else deadline - time.time() 1443 try: 1444 plumbing_response = self.stub.Delete( 1445 req, 1446 metadata=self.parent.get_metadata( 1447 'ApprovalWorkflowApprovers.Delete', req), 1448 timeout=t) 1449 except Exception as e: 1450 if self.parent.shouldRetry(tries, e, deadline): 1451 tries += 1 1452 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1453 continue 1454 raise plumbing.convert_error_to_porcelain(e) from e 1455 break 1456 1457 resp = models.ApprovalWorkflowApproverDeleteResponse() 1458 resp.id = (plumbing_response.id) 1459 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1460 plumbing_response.rate_limit) 1461 return resp 1462 1463 def list(self, filter, *args, timeout=None): 1464 ''' 1465 Deprecated: Lists existing approval workflow approvers. 1466 ''' 1467 deadline = None if timeout is None else time.time() + timeout 1468 req = ApprovalWorkflowApproverListRequest() 1469 req.meta.CopyFrom(ListRequestMetadata()) 1470 if self.parent.page_limit > 0: 1471 req.meta.limit = self.parent.page_limit 1472 if self.parent.snapshot_datetime is not None: 1473 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1474 1475 req.filter = plumbing.quote_filter_args(filter, *args) 1476 1477 def generator(svc, req): 1478 tries = 0 1479 while True: 1480 t = None if deadline is None else deadline - time.time() 1481 try: 1482 plumbing_response = svc.stub.List( 1483 req, 1484 metadata=svc.parent.get_metadata( 1485 'ApprovalWorkflowApprovers.List', req), 1486 timeout=t) 1487 except Exception as e: 1488 if self.parent.shouldRetry(tries, e, deadline): 1489 tries += 1 1490 time.sleep( 1491 self.parent.exponentialBackoff(tries, deadline)) 1492 continue 1493 raise plumbing.convert_error_to_porcelain(e) from e 1494 tries = 0 1495 for plumbing_item in plumbing_response.approval_workflow_approvers: 1496 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1497 plumbing_item) 1498 if plumbing_response.meta.next_cursor == '': 1499 break 1500 req.meta.cursor = plumbing_response.meta.next_cursor 1501 1502 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1357 def create(self, approval_workflow_approver, timeout=None): 1358 ''' 1359 Deprecated: Create creates a new approval workflow approver. 1360 ''' 1361 deadline = None if timeout is None else time.time() + timeout 1362 req = ApprovalWorkflowApproverCreateRequest() 1363 1364 if approval_workflow_approver is not None: 1365 req.approval_workflow_approver.CopyFrom( 1366 plumbing.convert_approval_workflow_approver_to_plumbing( 1367 approval_workflow_approver)) 1368 tries = 0 1369 plumbing_response = None 1370 while True: 1371 t = None if deadline is None else deadline - time.time() 1372 try: 1373 plumbing_response = self.stub.Create( 1374 req, 1375 metadata=self.parent.get_metadata( 1376 'ApprovalWorkflowApprovers.Create', req), 1377 timeout=t) 1378 except Exception as e: 1379 if self.parent.shouldRetry(tries, e, deadline): 1380 tries += 1 1381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1382 continue 1383 raise plumbing.convert_error_to_porcelain(e) from e 1384 break 1385 1386 resp = models.ApprovalWorkflowApproverCreateResponse() 1387 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1388 plumbing_response.approval_workflow_approver) 1389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1390 plumbing_response.rate_limit) 1391 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1393 def get(self, id, timeout=None): 1394 ''' 1395 Deprecated: Get reads one approval workflow approver by ID. 1396 ''' 1397 deadline = None if timeout is None else time.time() + timeout 1398 req = ApprovalWorkflowApproverGetRequest() 1399 if self.parent.snapshot_datetime is not None: 1400 req.meta.CopyFrom(GetRequestMetadata()) 1401 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1402 1403 req.id = (id) 1404 tries = 0 1405 plumbing_response = None 1406 while True: 1407 t = None if deadline is None else deadline - time.time() 1408 try: 1409 plumbing_response = self.stub.Get( 1410 req, 1411 metadata=self.parent.get_metadata( 1412 'ApprovalWorkflowApprovers.Get', req), 1413 timeout=t) 1414 except Exception as e: 1415 if self.parent.shouldRetry(tries, e, deadline): 1416 tries += 1 1417 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1418 continue 1419 raise plumbing.convert_error_to_porcelain(e) from e 1420 break 1421 1422 resp = models.ApprovalWorkflowApproverGetResponse() 1423 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1424 plumbing_response.approval_workflow_approver) 1425 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1426 plumbing_response.meta) 1427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1428 plumbing_response.rate_limit) 1429 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1431 def delete(self, id, timeout=None): 1432 ''' 1433 Deprecated: Delete deletes an existing approval workflow approver. 1434 ''' 1435 deadline = None if timeout is None else time.time() + timeout 1436 req = ApprovalWorkflowApproverDeleteRequest() 1437 1438 req.id = (id) 1439 tries = 0 1440 plumbing_response = None 1441 while True: 1442 t = None if deadline is None else deadline - time.time() 1443 try: 1444 plumbing_response = self.stub.Delete( 1445 req, 1446 metadata=self.parent.get_metadata( 1447 'ApprovalWorkflowApprovers.Delete', req), 1448 timeout=t) 1449 except Exception as e: 1450 if self.parent.shouldRetry(tries, e, deadline): 1451 tries += 1 1452 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1453 continue 1454 raise plumbing.convert_error_to_porcelain(e) from e 1455 break 1456 1457 resp = models.ApprovalWorkflowApproverDeleteResponse() 1458 resp.id = (plumbing_response.id) 1459 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1460 plumbing_response.rate_limit) 1461 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1463 def list(self, filter, *args, timeout=None): 1464 ''' 1465 Deprecated: Lists existing approval workflow approvers. 1466 ''' 1467 deadline = None if timeout is None else time.time() + timeout 1468 req = ApprovalWorkflowApproverListRequest() 1469 req.meta.CopyFrom(ListRequestMetadata()) 1470 if self.parent.page_limit > 0: 1471 req.meta.limit = self.parent.page_limit 1472 if self.parent.snapshot_datetime is not None: 1473 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1474 1475 req.filter = plumbing.quote_filter_args(filter, *args) 1476 1477 def generator(svc, req): 1478 tries = 0 1479 while True: 1480 t = None if deadline is None else deadline - time.time() 1481 try: 1482 plumbing_response = svc.stub.List( 1483 req, 1484 metadata=svc.parent.get_metadata( 1485 'ApprovalWorkflowApprovers.List', req), 1486 timeout=t) 1487 except Exception as e: 1488 if self.parent.shouldRetry(tries, e, deadline): 1489 tries += 1 1490 time.sleep( 1491 self.parent.exponentialBackoff(tries, deadline)) 1492 continue 1493 raise plumbing.convert_error_to_porcelain(e) from e 1494 tries = 0 1495 for plumbing_item in plumbing_response.approval_workflow_approvers: 1496 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1497 plumbing_item) 1498 if plumbing_response.meta.next_cursor == '': 1499 break 1500 req.meta.cursor = plumbing_response.meta.next_cursor 1501 1502 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1505class SnapshotApprovalWorkflowApprovers: 1506 ''' 1507 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1508 service for historical queries. 1509 ''' 1510 def __init__(self, approval_workflow_approvers): 1511 self.approval_workflow_approvers = approval_workflow_approvers 1512 1513 def get(self, id, timeout=None): 1514 ''' 1515 Deprecated: Get reads one approval workflow approver by ID. 1516 ''' 1517 return self.approval_workflow_approvers.get(id, timeout=timeout) 1518 1519 def list(self, filter, *args, timeout=None): 1520 ''' 1521 Deprecated: Lists existing approval workflow approvers. 1522 ''' 1523 return self.approval_workflow_approvers.list(filter, 1524 *args, 1525 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1513 def get(self, id, timeout=None): 1514 ''' 1515 Deprecated: Get reads one approval workflow approver by ID. 1516 ''' 1517 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)
1519 def list(self, filter, *args, timeout=None): 1520 ''' 1521 Deprecated: Lists existing approval workflow approvers. 1522 ''' 1523 return self.approval_workflow_approvers.list(filter, 1524 *args, 1525 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1528class ApprovalWorkflowApproversHistory: 1529 ''' 1530 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1531 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1532 ''' 1533 def __init__(self, channel, client): 1534 self.parent = client 1535 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1536 1537 def list(self, filter, *args, timeout=None): 1538 ''' 1539 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1540 ''' 1541 deadline = None if timeout is None else time.time() + timeout 1542 req = ApprovalWorkflowApproverHistoryListRequest() 1543 req.meta.CopyFrom(ListRequestMetadata()) 1544 if self.parent.page_limit > 0: 1545 req.meta.limit = self.parent.page_limit 1546 if self.parent.snapshot_datetime is not None: 1547 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1548 1549 req.filter = plumbing.quote_filter_args(filter, *args) 1550 1551 def generator(svc, req): 1552 tries = 0 1553 while True: 1554 t = None if deadline is None else deadline - time.time() 1555 try: 1556 plumbing_response = svc.stub.List( 1557 req, 1558 metadata=svc.parent.get_metadata( 1559 'ApprovalWorkflowApproversHistory.List', req), 1560 timeout=t) 1561 except Exception as e: 1562 if self.parent.shouldRetry(tries, e, deadline): 1563 tries += 1 1564 time.sleep( 1565 self.parent.exponentialBackoff(tries, deadline)) 1566 continue 1567 raise plumbing.convert_error_to_porcelain(e) from e 1568 tries = 0 1569 for plumbing_item in plumbing_response.history: 1570 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1571 plumbing_item) 1572 if plumbing_response.meta.next_cursor == '': 1573 break 1574 req.meta.cursor = plumbing_response.meta.next_cursor 1575 1576 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)
1537 def list(self, filter, *args, timeout=None): 1538 ''' 1539 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1540 ''' 1541 deadline = None if timeout is None else time.time() + timeout 1542 req = ApprovalWorkflowApproverHistoryListRequest() 1543 req.meta.CopyFrom(ListRequestMetadata()) 1544 if self.parent.page_limit > 0: 1545 req.meta.limit = self.parent.page_limit 1546 if self.parent.snapshot_datetime is not None: 1547 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1548 1549 req.filter = plumbing.quote_filter_args(filter, *args) 1550 1551 def generator(svc, req): 1552 tries = 0 1553 while True: 1554 t = None if deadline is None else deadline - time.time() 1555 try: 1556 plumbing_response = svc.stub.List( 1557 req, 1558 metadata=svc.parent.get_metadata( 1559 'ApprovalWorkflowApproversHistory.List', req), 1560 timeout=t) 1561 except Exception as e: 1562 if self.parent.shouldRetry(tries, e, deadline): 1563 tries += 1 1564 time.sleep( 1565 self.parent.exponentialBackoff(tries, deadline)) 1566 continue 1567 raise plumbing.convert_error_to_porcelain(e) from e 1568 tries = 0 1569 for plumbing_item in plumbing_response.history: 1570 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1571 plumbing_item) 1572 if plumbing_response.meta.next_cursor == '': 1573 break 1574 req.meta.cursor = plumbing_response.meta.next_cursor 1575 1576 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1579class ApprovalWorkflowSteps: 1580 ''' 1581 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1582 See `strongdm.models.ApprovalWorkflowStep`. 1583 ''' 1584 def __init__(self, channel, client): 1585 self.parent = client 1586 self.stub = ApprovalWorkflowStepsStub(channel) 1587 1588 def create(self, approval_workflow_step, timeout=None): 1589 ''' 1590 Deprecated: Create creates a new approval workflow step. 1591 ''' 1592 deadline = None if timeout is None else time.time() + timeout 1593 req = ApprovalWorkflowStepCreateRequest() 1594 1595 if approval_workflow_step is not None: 1596 req.approval_workflow_step.CopyFrom( 1597 plumbing.convert_approval_workflow_step_to_plumbing( 1598 approval_workflow_step)) 1599 tries = 0 1600 plumbing_response = None 1601 while True: 1602 t = None if deadline is None else deadline - time.time() 1603 try: 1604 plumbing_response = self.stub.Create( 1605 req, 1606 metadata=self.parent.get_metadata( 1607 'ApprovalWorkflowSteps.Create', req), 1608 timeout=t) 1609 except Exception as e: 1610 if self.parent.shouldRetry(tries, e, deadline): 1611 tries += 1 1612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1613 continue 1614 raise plumbing.convert_error_to_porcelain(e) from e 1615 break 1616 1617 resp = models.ApprovalWorkflowStepCreateResponse() 1618 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1619 plumbing_response.approval_workflow_step) 1620 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1621 plumbing_response.rate_limit) 1622 return resp 1623 1624 def get(self, id, timeout=None): 1625 ''' 1626 Deprecated: Get reads one approval workflow step by ID. 1627 ''' 1628 deadline = None if timeout is None else time.time() + timeout 1629 req = ApprovalWorkflowStepGetRequest() 1630 if self.parent.snapshot_datetime is not None: 1631 req.meta.CopyFrom(GetRequestMetadata()) 1632 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1633 1634 req.id = (id) 1635 tries = 0 1636 plumbing_response = None 1637 while True: 1638 t = None if deadline is None else deadline - time.time() 1639 try: 1640 plumbing_response = self.stub.Get( 1641 req, 1642 metadata=self.parent.get_metadata( 1643 'ApprovalWorkflowSteps.Get', req), 1644 timeout=t) 1645 except Exception as e: 1646 if self.parent.shouldRetry(tries, e, deadline): 1647 tries += 1 1648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1649 continue 1650 raise plumbing.convert_error_to_porcelain(e) from e 1651 break 1652 1653 resp = models.ApprovalWorkflowStepGetResponse() 1654 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1655 plumbing_response.approval_workflow_step) 1656 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1657 plumbing_response.meta) 1658 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1659 plumbing_response.rate_limit) 1660 return resp 1661 1662 def delete(self, id, timeout=None): 1663 ''' 1664 Deprecated: Delete deletes an existing approval workflow step. 1665 ''' 1666 deadline = None if timeout is None else time.time() + timeout 1667 req = ApprovalWorkflowStepDeleteRequest() 1668 1669 req.id = (id) 1670 tries = 0 1671 plumbing_response = None 1672 while True: 1673 t = None if deadline is None else deadline - time.time() 1674 try: 1675 plumbing_response = self.stub.Delete( 1676 req, 1677 metadata=self.parent.get_metadata( 1678 'ApprovalWorkflowSteps.Delete', req), 1679 timeout=t) 1680 except Exception as e: 1681 if self.parent.shouldRetry(tries, e, deadline): 1682 tries += 1 1683 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1684 continue 1685 raise plumbing.convert_error_to_porcelain(e) from e 1686 break 1687 1688 resp = models.ApprovalWorkflowStepDeleteResponse() 1689 resp.id = (plumbing_response.id) 1690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1691 plumbing_response.rate_limit) 1692 return resp 1693 1694 def list(self, filter, *args, timeout=None): 1695 ''' 1696 Deprecated: Lists existing approval workflow steps. 1697 ''' 1698 deadline = None if timeout is None else time.time() + timeout 1699 req = ApprovalWorkflowStepListRequest() 1700 req.meta.CopyFrom(ListRequestMetadata()) 1701 if self.parent.page_limit > 0: 1702 req.meta.limit = self.parent.page_limit 1703 if self.parent.snapshot_datetime is not None: 1704 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1705 1706 req.filter = plumbing.quote_filter_args(filter, *args) 1707 1708 def generator(svc, req): 1709 tries = 0 1710 while True: 1711 t = None if deadline is None else deadline - time.time() 1712 try: 1713 plumbing_response = svc.stub.List( 1714 req, 1715 metadata=svc.parent.get_metadata( 1716 'ApprovalWorkflowSteps.List', req), 1717 timeout=t) 1718 except Exception as e: 1719 if self.parent.shouldRetry(tries, e, deadline): 1720 tries += 1 1721 time.sleep( 1722 self.parent.exponentialBackoff(tries, deadline)) 1723 continue 1724 raise plumbing.convert_error_to_porcelain(e) from e 1725 tries = 0 1726 for plumbing_item in plumbing_response.approval_workflow_steps: 1727 yield plumbing.convert_approval_workflow_step_to_porcelain( 1728 plumbing_item) 1729 if plumbing_response.meta.next_cursor == '': 1730 break 1731 req.meta.cursor = plumbing_response.meta.next_cursor 1732 1733 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1588 def create(self, approval_workflow_step, timeout=None): 1589 ''' 1590 Deprecated: Create creates a new approval workflow step. 1591 ''' 1592 deadline = None if timeout is None else time.time() + timeout 1593 req = ApprovalWorkflowStepCreateRequest() 1594 1595 if approval_workflow_step is not None: 1596 req.approval_workflow_step.CopyFrom( 1597 plumbing.convert_approval_workflow_step_to_plumbing( 1598 approval_workflow_step)) 1599 tries = 0 1600 plumbing_response = None 1601 while True: 1602 t = None if deadline is None else deadline - time.time() 1603 try: 1604 plumbing_response = self.stub.Create( 1605 req, 1606 metadata=self.parent.get_metadata( 1607 'ApprovalWorkflowSteps.Create', req), 1608 timeout=t) 1609 except Exception as e: 1610 if self.parent.shouldRetry(tries, e, deadline): 1611 tries += 1 1612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1613 continue 1614 raise plumbing.convert_error_to_porcelain(e) from e 1615 break 1616 1617 resp = models.ApprovalWorkflowStepCreateResponse() 1618 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1619 plumbing_response.approval_workflow_step) 1620 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1621 plumbing_response.rate_limit) 1622 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1624 def get(self, id, timeout=None): 1625 ''' 1626 Deprecated: Get reads one approval workflow step by ID. 1627 ''' 1628 deadline = None if timeout is None else time.time() + timeout 1629 req = ApprovalWorkflowStepGetRequest() 1630 if self.parent.snapshot_datetime is not None: 1631 req.meta.CopyFrom(GetRequestMetadata()) 1632 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1633 1634 req.id = (id) 1635 tries = 0 1636 plumbing_response = None 1637 while True: 1638 t = None if deadline is None else deadline - time.time() 1639 try: 1640 plumbing_response = self.stub.Get( 1641 req, 1642 metadata=self.parent.get_metadata( 1643 'ApprovalWorkflowSteps.Get', req), 1644 timeout=t) 1645 except Exception as e: 1646 if self.parent.shouldRetry(tries, e, deadline): 1647 tries += 1 1648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1649 continue 1650 raise plumbing.convert_error_to_porcelain(e) from e 1651 break 1652 1653 resp = models.ApprovalWorkflowStepGetResponse() 1654 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1655 plumbing_response.approval_workflow_step) 1656 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1657 plumbing_response.meta) 1658 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1659 plumbing_response.rate_limit) 1660 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1662 def delete(self, id, timeout=None): 1663 ''' 1664 Deprecated: Delete deletes an existing approval workflow step. 1665 ''' 1666 deadline = None if timeout is None else time.time() + timeout 1667 req = ApprovalWorkflowStepDeleteRequest() 1668 1669 req.id = (id) 1670 tries = 0 1671 plumbing_response = None 1672 while True: 1673 t = None if deadline is None else deadline - time.time() 1674 try: 1675 plumbing_response = self.stub.Delete( 1676 req, 1677 metadata=self.parent.get_metadata( 1678 'ApprovalWorkflowSteps.Delete', req), 1679 timeout=t) 1680 except Exception as e: 1681 if self.parent.shouldRetry(tries, e, deadline): 1682 tries += 1 1683 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1684 continue 1685 raise plumbing.convert_error_to_porcelain(e) from e 1686 break 1687 1688 resp = models.ApprovalWorkflowStepDeleteResponse() 1689 resp.id = (plumbing_response.id) 1690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1691 plumbing_response.rate_limit) 1692 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1694 def list(self, filter, *args, timeout=None): 1695 ''' 1696 Deprecated: Lists existing approval workflow steps. 1697 ''' 1698 deadline = None if timeout is None else time.time() + timeout 1699 req = ApprovalWorkflowStepListRequest() 1700 req.meta.CopyFrom(ListRequestMetadata()) 1701 if self.parent.page_limit > 0: 1702 req.meta.limit = self.parent.page_limit 1703 if self.parent.snapshot_datetime is not None: 1704 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1705 1706 req.filter = plumbing.quote_filter_args(filter, *args) 1707 1708 def generator(svc, req): 1709 tries = 0 1710 while True: 1711 t = None if deadline is None else deadline - time.time() 1712 try: 1713 plumbing_response = svc.stub.List( 1714 req, 1715 metadata=svc.parent.get_metadata( 1716 'ApprovalWorkflowSteps.List', req), 1717 timeout=t) 1718 except Exception as e: 1719 if self.parent.shouldRetry(tries, e, deadline): 1720 tries += 1 1721 time.sleep( 1722 self.parent.exponentialBackoff(tries, deadline)) 1723 continue 1724 raise plumbing.convert_error_to_porcelain(e) from e 1725 tries = 0 1726 for plumbing_item in plumbing_response.approval_workflow_steps: 1727 yield plumbing.convert_approval_workflow_step_to_porcelain( 1728 plumbing_item) 1729 if plumbing_response.meta.next_cursor == '': 1730 break 1731 req.meta.cursor = plumbing_response.meta.next_cursor 1732 1733 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1736class SnapshotApprovalWorkflowSteps: 1737 ''' 1738 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1739 service for historical queries. 1740 ''' 1741 def __init__(self, approval_workflow_steps): 1742 self.approval_workflow_steps = approval_workflow_steps 1743 1744 def get(self, id, timeout=None): 1745 ''' 1746 Deprecated: Get reads one approval workflow step by ID. 1747 ''' 1748 return self.approval_workflow_steps.get(id, timeout=timeout) 1749 1750 def list(self, filter, *args, timeout=None): 1751 ''' 1752 Deprecated: Lists existing approval workflow steps. 1753 ''' 1754 return self.approval_workflow_steps.list(filter, 1755 *args, 1756 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1744 def get(self, id, timeout=None): 1745 ''' 1746 Deprecated: Get reads one approval workflow step by ID. 1747 ''' 1748 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)
1750 def list(self, filter, *args, timeout=None): 1751 ''' 1752 Deprecated: Lists existing approval workflow steps. 1753 ''' 1754 return self.approval_workflow_steps.list(filter, 1755 *args, 1756 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
1759class ApprovalWorkflowStepsHistory: 1760 ''' 1761 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 1762 See `strongdm.models.ApprovalWorkflowStepHistory`. 1763 ''' 1764 def __init__(self, channel, client): 1765 self.parent = client 1766 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 1767 1768 def list(self, filter, *args, timeout=None): 1769 ''' 1770 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1771 ''' 1772 deadline = None if timeout is None else time.time() + timeout 1773 req = ApprovalWorkflowStepHistoryListRequest() 1774 req.meta.CopyFrom(ListRequestMetadata()) 1775 if self.parent.page_limit > 0: 1776 req.meta.limit = self.parent.page_limit 1777 if self.parent.snapshot_datetime is not None: 1778 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1779 1780 req.filter = plumbing.quote_filter_args(filter, *args) 1781 1782 def generator(svc, req): 1783 tries = 0 1784 while True: 1785 t = None if deadline is None else deadline - time.time() 1786 try: 1787 plumbing_response = svc.stub.List( 1788 req, 1789 metadata=svc.parent.get_metadata( 1790 'ApprovalWorkflowStepsHistory.List', req), 1791 timeout=t) 1792 except Exception as e: 1793 if self.parent.shouldRetry(tries, e, deadline): 1794 tries += 1 1795 time.sleep( 1796 self.parent.exponentialBackoff(tries, deadline)) 1797 continue 1798 raise plumbing.convert_error_to_porcelain(e) from e 1799 tries = 0 1800 for plumbing_item in plumbing_response.history: 1801 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1802 plumbing_item) 1803 if plumbing_response.meta.next_cursor == '': 1804 break 1805 req.meta.cursor = plumbing_response.meta.next_cursor 1806 1807 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)
1768 def list(self, filter, *args, timeout=None): 1769 ''' 1770 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 1771 ''' 1772 deadline = None if timeout is None else time.time() + timeout 1773 req = ApprovalWorkflowStepHistoryListRequest() 1774 req.meta.CopyFrom(ListRequestMetadata()) 1775 if self.parent.page_limit > 0: 1776 req.meta.limit = self.parent.page_limit 1777 if self.parent.snapshot_datetime is not None: 1778 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1779 1780 req.filter = plumbing.quote_filter_args(filter, *args) 1781 1782 def generator(svc, req): 1783 tries = 0 1784 while True: 1785 t = None if deadline is None else deadline - time.time() 1786 try: 1787 plumbing_response = svc.stub.List( 1788 req, 1789 metadata=svc.parent.get_metadata( 1790 'ApprovalWorkflowStepsHistory.List', req), 1791 timeout=t) 1792 except Exception as e: 1793 if self.parent.shouldRetry(tries, e, deadline): 1794 tries += 1 1795 time.sleep( 1796 self.parent.exponentialBackoff(tries, deadline)) 1797 continue 1798 raise plumbing.convert_error_to_porcelain(e) from e 1799 tries = 0 1800 for plumbing_item in plumbing_response.history: 1801 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 1802 plumbing_item) 1803 if plumbing_response.meta.next_cursor == '': 1804 break 1805 req.meta.cursor = plumbing_response.meta.next_cursor 1806 1807 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
1810class ApprovalWorkflows: 1811 ''' 1812 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 1813 approvers and be approved or denied. 1814 See `strongdm.models.ApprovalWorkflow`. 1815 ''' 1816 def __init__(self, channel, client): 1817 self.parent = client 1818 self.stub = ApprovalWorkflowsStub(channel) 1819 1820 def create(self, approval_workflow, timeout=None): 1821 ''' 1822 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1823 ''' 1824 deadline = None if timeout is None else time.time() + timeout 1825 req = ApprovalWorkflowCreateRequest() 1826 1827 if approval_workflow is not None: 1828 req.approval_workflow.CopyFrom( 1829 plumbing.convert_approval_workflow_to_plumbing( 1830 approval_workflow)) 1831 tries = 0 1832 plumbing_response = None 1833 while True: 1834 t = None if deadline is None else deadline - time.time() 1835 try: 1836 plumbing_response = self.stub.Create( 1837 req, 1838 metadata=self.parent.get_metadata( 1839 'ApprovalWorkflows.Create', req), 1840 timeout=t) 1841 except Exception as e: 1842 if self.parent.shouldRetry(tries, e, deadline): 1843 tries += 1 1844 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1845 continue 1846 raise plumbing.convert_error_to_porcelain(e) from e 1847 break 1848 1849 resp = models.ApprovalWorkflowCreateResponse() 1850 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1851 plumbing_response.approval_workflow) 1852 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1853 plumbing_response.rate_limit) 1854 return resp 1855 1856 def get(self, id, timeout=None): 1857 ''' 1858 Get reads one approval workflow by ID. 1859 ''' 1860 deadline = None if timeout is None else time.time() + timeout 1861 req = ApprovalWorkflowGetRequest() 1862 if self.parent.snapshot_datetime is not None: 1863 req.meta.CopyFrom(GetRequestMetadata()) 1864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1865 1866 req.id = (id) 1867 tries = 0 1868 plumbing_response = None 1869 while True: 1870 t = None if deadline is None else deadline - time.time() 1871 try: 1872 plumbing_response = self.stub.Get( 1873 req, 1874 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1875 req), 1876 timeout=t) 1877 except Exception as e: 1878 if self.parent.shouldRetry(tries, e, deadline): 1879 tries += 1 1880 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1881 continue 1882 raise plumbing.convert_error_to_porcelain(e) from e 1883 break 1884 1885 resp = models.ApprovalWorkflowGetResponse() 1886 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1887 plumbing_response.approval_workflow) 1888 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1889 plumbing_response.meta) 1890 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1891 plumbing_response.rate_limit) 1892 return resp 1893 1894 def delete(self, id, timeout=None): 1895 ''' 1896 Delete deletes an existing approval workflow. 1897 ''' 1898 deadline = None if timeout is None else time.time() + timeout 1899 req = ApprovalWorkflowDeleteRequest() 1900 1901 req.id = (id) 1902 tries = 0 1903 plumbing_response = None 1904 while True: 1905 t = None if deadline is None else deadline - time.time() 1906 try: 1907 plumbing_response = self.stub.Delete( 1908 req, 1909 metadata=self.parent.get_metadata( 1910 'ApprovalWorkflows.Delete', req), 1911 timeout=t) 1912 except Exception as e: 1913 if self.parent.shouldRetry(tries, e, deadline): 1914 tries += 1 1915 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1916 continue 1917 raise plumbing.convert_error_to_porcelain(e) from e 1918 break 1919 1920 resp = models.ApprovalWorkflowDeleteResponse() 1921 resp.id = (plumbing_response.id) 1922 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1923 plumbing_response.rate_limit) 1924 return resp 1925 1926 def update(self, approval_workflow, timeout=None): 1927 ''' 1928 Update updates an existing approval workflow. 1929 ''' 1930 deadline = None if timeout is None else time.time() + timeout 1931 req = ApprovalWorkflowUpdateRequest() 1932 1933 if approval_workflow is not None: 1934 req.approval_workflow.CopyFrom( 1935 plumbing.convert_approval_workflow_to_plumbing( 1936 approval_workflow)) 1937 tries = 0 1938 plumbing_response = None 1939 while True: 1940 t = None if deadline is None else deadline - time.time() 1941 try: 1942 plumbing_response = self.stub.Update( 1943 req, 1944 metadata=self.parent.get_metadata( 1945 'ApprovalWorkflows.Update', req), 1946 timeout=t) 1947 except Exception as e: 1948 if self.parent.shouldRetry(tries, e, deadline): 1949 tries += 1 1950 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1951 continue 1952 raise plumbing.convert_error_to_porcelain(e) from e 1953 break 1954 1955 resp = models.ApprovalWorkflowUpdateResponse() 1956 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1957 plumbing_response.approval_workflow) 1958 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1959 plumbing_response.rate_limit) 1960 return resp 1961 1962 def list(self, filter, *args, timeout=None): 1963 ''' 1964 Lists existing approval workflows. 1965 ''' 1966 deadline = None if timeout is None else time.time() + timeout 1967 req = ApprovalWorkflowListRequest() 1968 req.meta.CopyFrom(ListRequestMetadata()) 1969 if self.parent.page_limit > 0: 1970 req.meta.limit = self.parent.page_limit 1971 if self.parent.snapshot_datetime is not None: 1972 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1973 1974 req.filter = plumbing.quote_filter_args(filter, *args) 1975 1976 def generator(svc, req): 1977 tries = 0 1978 while True: 1979 t = None if deadline is None else deadline - time.time() 1980 try: 1981 plumbing_response = svc.stub.List( 1982 req, 1983 metadata=svc.parent.get_metadata( 1984 'ApprovalWorkflows.List', req), 1985 timeout=t) 1986 except Exception as e: 1987 if self.parent.shouldRetry(tries, e, deadline): 1988 tries += 1 1989 time.sleep( 1990 self.parent.exponentialBackoff(tries, deadline)) 1991 continue 1992 raise plumbing.convert_error_to_porcelain(e) from e 1993 tries = 0 1994 for plumbing_item in plumbing_response.approval_workflows: 1995 yield plumbing.convert_approval_workflow_to_porcelain( 1996 plumbing_item) 1997 if plumbing_response.meta.next_cursor == '': 1998 break 1999 req.meta.cursor = plumbing_response.meta.next_cursor 2000 2001 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)
1820 def create(self, approval_workflow, timeout=None): 1821 ''' 1822 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 1823 ''' 1824 deadline = None if timeout is None else time.time() + timeout 1825 req = ApprovalWorkflowCreateRequest() 1826 1827 if approval_workflow is not None: 1828 req.approval_workflow.CopyFrom( 1829 plumbing.convert_approval_workflow_to_plumbing( 1830 approval_workflow)) 1831 tries = 0 1832 plumbing_response = None 1833 while True: 1834 t = None if deadline is None else deadline - time.time() 1835 try: 1836 plumbing_response = self.stub.Create( 1837 req, 1838 metadata=self.parent.get_metadata( 1839 'ApprovalWorkflows.Create', req), 1840 timeout=t) 1841 except Exception as e: 1842 if self.parent.shouldRetry(tries, e, deadline): 1843 tries += 1 1844 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1845 continue 1846 raise plumbing.convert_error_to_porcelain(e) from e 1847 break 1848 1849 resp = models.ApprovalWorkflowCreateResponse() 1850 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1851 plumbing_response.approval_workflow) 1852 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1853 plumbing_response.rate_limit) 1854 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)
1856 def get(self, id, timeout=None): 1857 ''' 1858 Get reads one approval workflow by ID. 1859 ''' 1860 deadline = None if timeout is None else time.time() + timeout 1861 req = ApprovalWorkflowGetRequest() 1862 if self.parent.snapshot_datetime is not None: 1863 req.meta.CopyFrom(GetRequestMetadata()) 1864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1865 1866 req.id = (id) 1867 tries = 0 1868 plumbing_response = None 1869 while True: 1870 t = None if deadline is None else deadline - time.time() 1871 try: 1872 plumbing_response = self.stub.Get( 1873 req, 1874 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 1875 req), 1876 timeout=t) 1877 except Exception as e: 1878 if self.parent.shouldRetry(tries, e, deadline): 1879 tries += 1 1880 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1881 continue 1882 raise plumbing.convert_error_to_porcelain(e) from e 1883 break 1884 1885 resp = models.ApprovalWorkflowGetResponse() 1886 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1887 plumbing_response.approval_workflow) 1888 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1889 plumbing_response.meta) 1890 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1891 plumbing_response.rate_limit) 1892 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
1894 def delete(self, id, timeout=None): 1895 ''' 1896 Delete deletes an existing approval workflow. 1897 ''' 1898 deadline = None if timeout is None else time.time() + timeout 1899 req = ApprovalWorkflowDeleteRequest() 1900 1901 req.id = (id) 1902 tries = 0 1903 plumbing_response = None 1904 while True: 1905 t = None if deadline is None else deadline - time.time() 1906 try: 1907 plumbing_response = self.stub.Delete( 1908 req, 1909 metadata=self.parent.get_metadata( 1910 'ApprovalWorkflows.Delete', req), 1911 timeout=t) 1912 except Exception as e: 1913 if self.parent.shouldRetry(tries, e, deadline): 1914 tries += 1 1915 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1916 continue 1917 raise plumbing.convert_error_to_porcelain(e) from e 1918 break 1919 1920 resp = models.ApprovalWorkflowDeleteResponse() 1921 resp.id = (plumbing_response.id) 1922 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1923 plumbing_response.rate_limit) 1924 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
1926 def update(self, approval_workflow, timeout=None): 1927 ''' 1928 Update updates an existing approval workflow. 1929 ''' 1930 deadline = None if timeout is None else time.time() + timeout 1931 req = ApprovalWorkflowUpdateRequest() 1932 1933 if approval_workflow is not None: 1934 req.approval_workflow.CopyFrom( 1935 plumbing.convert_approval_workflow_to_plumbing( 1936 approval_workflow)) 1937 tries = 0 1938 plumbing_response = None 1939 while True: 1940 t = None if deadline is None else deadline - time.time() 1941 try: 1942 plumbing_response = self.stub.Update( 1943 req, 1944 metadata=self.parent.get_metadata( 1945 'ApprovalWorkflows.Update', req), 1946 timeout=t) 1947 except Exception as e: 1948 if self.parent.shouldRetry(tries, e, deadline): 1949 tries += 1 1950 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1951 continue 1952 raise plumbing.convert_error_to_porcelain(e) from e 1953 break 1954 1955 resp = models.ApprovalWorkflowUpdateResponse() 1956 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 1957 plumbing_response.approval_workflow) 1958 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1959 plumbing_response.rate_limit) 1960 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
1962 def list(self, filter, *args, timeout=None): 1963 ''' 1964 Lists existing approval workflows. 1965 ''' 1966 deadline = None if timeout is None else time.time() + timeout 1967 req = ApprovalWorkflowListRequest() 1968 req.meta.CopyFrom(ListRequestMetadata()) 1969 if self.parent.page_limit > 0: 1970 req.meta.limit = self.parent.page_limit 1971 if self.parent.snapshot_datetime is not None: 1972 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1973 1974 req.filter = plumbing.quote_filter_args(filter, *args) 1975 1976 def generator(svc, req): 1977 tries = 0 1978 while True: 1979 t = None if deadline is None else deadline - time.time() 1980 try: 1981 plumbing_response = svc.stub.List( 1982 req, 1983 metadata=svc.parent.get_metadata( 1984 'ApprovalWorkflows.List', req), 1985 timeout=t) 1986 except Exception as e: 1987 if self.parent.shouldRetry(tries, e, deadline): 1988 tries += 1 1989 time.sleep( 1990 self.parent.exponentialBackoff(tries, deadline)) 1991 continue 1992 raise plumbing.convert_error_to_porcelain(e) from e 1993 tries = 0 1994 for plumbing_item in plumbing_response.approval_workflows: 1995 yield plumbing.convert_approval_workflow_to_porcelain( 1996 plumbing_item) 1997 if plumbing_response.meta.next_cursor == '': 1998 break 1999 req.meta.cursor = plumbing_response.meta.next_cursor 2000 2001 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2004class SnapshotApprovalWorkflows: 2005 ''' 2006 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2007 service for historical queries. 2008 ''' 2009 def __init__(self, approval_workflows): 2010 self.approval_workflows = approval_workflows 2011 2012 def get(self, id, timeout=None): 2013 ''' 2014 Get reads one approval workflow by ID. 2015 ''' 2016 return self.approval_workflows.get(id, timeout=timeout) 2017 2018 def list(self, filter, *args, timeout=None): 2019 ''' 2020 Lists existing approval workflows. 2021 ''' 2022 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2025class ApprovalWorkflowsHistory: 2026 ''' 2027 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2028 See `strongdm.models.ApprovalWorkflowHistory`. 2029 ''' 2030 def __init__(self, channel, client): 2031 self.parent = client 2032 self.stub = ApprovalWorkflowsHistoryStub(channel) 2033 2034 def list(self, filter, *args, timeout=None): 2035 ''' 2036 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2037 ''' 2038 deadline = None if timeout is None else time.time() + timeout 2039 req = ApprovalWorkflowHistoryListRequest() 2040 req.meta.CopyFrom(ListRequestMetadata()) 2041 if self.parent.page_limit > 0: 2042 req.meta.limit = self.parent.page_limit 2043 if self.parent.snapshot_datetime is not None: 2044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2045 2046 req.filter = plumbing.quote_filter_args(filter, *args) 2047 2048 def generator(svc, req): 2049 tries = 0 2050 while True: 2051 t = None if deadline is None else deadline - time.time() 2052 try: 2053 plumbing_response = svc.stub.List( 2054 req, 2055 metadata=svc.parent.get_metadata( 2056 'ApprovalWorkflowsHistory.List', req), 2057 timeout=t) 2058 except Exception as e: 2059 if self.parent.shouldRetry(tries, e, deadline): 2060 tries += 1 2061 time.sleep( 2062 self.parent.exponentialBackoff(tries, deadline)) 2063 continue 2064 raise plumbing.convert_error_to_porcelain(e) from e 2065 tries = 0 2066 for plumbing_item in plumbing_response.history: 2067 yield plumbing.convert_approval_workflow_history_to_porcelain( 2068 plumbing_item) 2069 if plumbing_response.meta.next_cursor == '': 2070 break 2071 req.meta.cursor = plumbing_response.meta.next_cursor 2072 2073 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)
2034 def list(self, filter, *args, timeout=None): 2035 ''' 2036 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2037 ''' 2038 deadline = None if timeout is None else time.time() + timeout 2039 req = ApprovalWorkflowHistoryListRequest() 2040 req.meta.CopyFrom(ListRequestMetadata()) 2041 if self.parent.page_limit > 0: 2042 req.meta.limit = self.parent.page_limit 2043 if self.parent.snapshot_datetime is not None: 2044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2045 2046 req.filter = plumbing.quote_filter_args(filter, *args) 2047 2048 def generator(svc, req): 2049 tries = 0 2050 while True: 2051 t = None if deadline is None else deadline - time.time() 2052 try: 2053 plumbing_response = svc.stub.List( 2054 req, 2055 metadata=svc.parent.get_metadata( 2056 'ApprovalWorkflowsHistory.List', req), 2057 timeout=t) 2058 except Exception as e: 2059 if self.parent.shouldRetry(tries, e, deadline): 2060 tries += 1 2061 time.sleep( 2062 self.parent.exponentialBackoff(tries, deadline)) 2063 continue 2064 raise plumbing.convert_error_to_porcelain(e) from e 2065 tries = 0 2066 for plumbing_item in plumbing_response.history: 2067 yield plumbing.convert_approval_workflow_history_to_porcelain( 2068 plumbing_item) 2069 if plumbing_response.meta.next_cursor == '': 2070 break 2071 req.meta.cursor = plumbing_response.meta.next_cursor 2072 2073 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2076class ControlPanel: 2077 ''' 2078 ControlPanel contains all administrative controls. 2079 ''' 2080 def __init__(self, channel, client): 2081 self.parent = client 2082 self.stub = ControlPanelStub(channel) 2083 2084 def get_sshca_public_key(self, timeout=None): 2085 ''' 2086 GetSSHCAPublicKey retrieves the SSH CA public key. 2087 ''' 2088 deadline = None if timeout is None else time.time() + timeout 2089 req = ControlPanelGetSSHCAPublicKeyRequest() 2090 2091 tries = 0 2092 plumbing_response = None 2093 while True: 2094 t = None if deadline is None else deadline - time.time() 2095 try: 2096 plumbing_response = self.stub.GetSSHCAPublicKey( 2097 req, 2098 metadata=self.parent.get_metadata( 2099 'ControlPanel.GetSSHCAPublicKey', req), 2100 timeout=t) 2101 except Exception as e: 2102 if self.parent.shouldRetry(tries, e, deadline): 2103 tries += 1 2104 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2105 continue 2106 raise plumbing.convert_error_to_porcelain(e) from e 2107 break 2108 2109 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2110 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2111 plumbing_response.meta) 2112 resp.public_key = (plumbing_response.public_key) 2113 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2114 plumbing_response.rate_limit) 2115 return resp 2116 2117 def get_rdpca_public_key(self, timeout=None): 2118 ''' 2119 GetRDPCAPublicKey retrieves the RDP CA public key. 2120 ''' 2121 deadline = None if timeout is None else time.time() + timeout 2122 req = ControlPanelGetRDPCAPublicKeyRequest() 2123 2124 tries = 0 2125 plumbing_response = None 2126 while True: 2127 t = None if deadline is None else deadline - time.time() 2128 try: 2129 plumbing_response = self.stub.GetRDPCAPublicKey( 2130 req, 2131 metadata=self.parent.get_metadata( 2132 'ControlPanel.GetRDPCAPublicKey', req), 2133 timeout=t) 2134 except Exception as e: 2135 if self.parent.shouldRetry(tries, e, deadline): 2136 tries += 1 2137 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2138 continue 2139 raise plumbing.convert_error_to_porcelain(e) from e 2140 break 2141 2142 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2144 plumbing_response.meta) 2145 resp.public_key = (plumbing_response.public_key) 2146 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2147 plumbing_response.rate_limit) 2148 return resp 2149 2150 def verify_jwt(self, token, timeout=None): 2151 ''' 2152 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2153 ''' 2154 deadline = None if timeout is None else time.time() + timeout 2155 req = ControlPanelVerifyJWTRequest() 2156 2157 req.token = (token) 2158 tries = 0 2159 plumbing_response = None 2160 while True: 2161 t = None if deadline is None else deadline - time.time() 2162 try: 2163 plumbing_response = self.stub.VerifyJWT( 2164 req, 2165 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2166 req), 2167 timeout=t) 2168 except Exception as e: 2169 if self.parent.shouldRetry(tries, e, deadline): 2170 tries += 1 2171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2172 continue 2173 raise plumbing.convert_error_to_porcelain(e) from e 2174 break 2175 2176 resp = models.ControlPanelVerifyJWTResponse() 2177 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2178 plumbing_response.meta) 2179 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2180 plumbing_response.rate_limit) 2181 resp.valid = (plumbing_response.valid) 2182 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2084 def get_sshca_public_key(self, timeout=None): 2085 ''' 2086 GetSSHCAPublicKey retrieves the SSH CA public key. 2087 ''' 2088 deadline = None if timeout is None else time.time() + timeout 2089 req = ControlPanelGetSSHCAPublicKeyRequest() 2090 2091 tries = 0 2092 plumbing_response = None 2093 while True: 2094 t = None if deadline is None else deadline - time.time() 2095 try: 2096 plumbing_response = self.stub.GetSSHCAPublicKey( 2097 req, 2098 metadata=self.parent.get_metadata( 2099 'ControlPanel.GetSSHCAPublicKey', req), 2100 timeout=t) 2101 except Exception as e: 2102 if self.parent.shouldRetry(tries, e, deadline): 2103 tries += 1 2104 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2105 continue 2106 raise plumbing.convert_error_to_porcelain(e) from e 2107 break 2108 2109 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2110 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2111 plumbing_response.meta) 2112 resp.public_key = (plumbing_response.public_key) 2113 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2114 plumbing_response.rate_limit) 2115 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2117 def get_rdpca_public_key(self, timeout=None): 2118 ''' 2119 GetRDPCAPublicKey retrieves the RDP CA public key. 2120 ''' 2121 deadline = None if timeout is None else time.time() + timeout 2122 req = ControlPanelGetRDPCAPublicKeyRequest() 2123 2124 tries = 0 2125 plumbing_response = None 2126 while True: 2127 t = None if deadline is None else deadline - time.time() 2128 try: 2129 plumbing_response = self.stub.GetRDPCAPublicKey( 2130 req, 2131 metadata=self.parent.get_metadata( 2132 'ControlPanel.GetRDPCAPublicKey', req), 2133 timeout=t) 2134 except Exception as e: 2135 if self.parent.shouldRetry(tries, e, deadline): 2136 tries += 1 2137 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2138 continue 2139 raise plumbing.convert_error_to_porcelain(e) from e 2140 break 2141 2142 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2144 plumbing_response.meta) 2145 resp.public_key = (plumbing_response.public_key) 2146 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2147 plumbing_response.rate_limit) 2148 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
verify_jwt(self, token, timeout=None)
2150 def verify_jwt(self, token, timeout=None): 2151 ''' 2152 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2153 ''' 2154 deadline = None if timeout is None else time.time() + timeout 2155 req = ControlPanelVerifyJWTRequest() 2156 2157 req.token = (token) 2158 tries = 0 2159 plumbing_response = None 2160 while True: 2161 t = None if deadline is None else deadline - time.time() 2162 try: 2163 plumbing_response = self.stub.VerifyJWT( 2164 req, 2165 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2166 req), 2167 timeout=t) 2168 except Exception as e: 2169 if self.parent.shouldRetry(tries, e, deadline): 2170 tries += 1 2171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2172 continue 2173 raise plumbing.convert_error_to_porcelain(e) from e 2174 break 2175 2176 resp = models.ControlPanelVerifyJWTResponse() 2177 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2178 plumbing_response.meta) 2179 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2180 plumbing_response.rate_limit) 2181 resp.valid = (plumbing_response.valid) 2182 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
Roles:
2185class Roles: 2186 ''' 2187 A Role has a list of access rules which determine which Resources the members 2188 of the Role have access to. An Account can be a member of multiple Roles via 2189 AccountAttachments. 2190 See `strongdm.models.Role`. 2191 ''' 2192 def __init__(self, channel, client): 2193 self.parent = client 2194 self.stub = RolesStub(channel) 2195 2196 def create(self, role, timeout=None): 2197 ''' 2198 Create registers a new Role. 2199 ''' 2200 deadline = None if timeout is None else time.time() + timeout 2201 req = RoleCreateRequest() 2202 2203 if role is not None: 2204 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2205 tries = 0 2206 plumbing_response = None 2207 while True: 2208 t = None if deadline is None else deadline - time.time() 2209 try: 2210 plumbing_response = self.stub.Create( 2211 req, 2212 metadata=self.parent.get_metadata('Roles.Create', req), 2213 timeout=t) 2214 except Exception as e: 2215 if self.parent.shouldRetry(tries, e, deadline): 2216 tries += 1 2217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2218 continue 2219 raise plumbing.convert_error_to_porcelain(e) from e 2220 break 2221 2222 resp = models.RoleCreateResponse() 2223 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2224 plumbing_response.meta) 2225 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2226 plumbing_response.rate_limit) 2227 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2228 return resp 2229 2230 def get(self, id, timeout=None): 2231 ''' 2232 Get reads one Role by ID. 2233 ''' 2234 deadline = None if timeout is None else time.time() + timeout 2235 req = RoleGetRequest() 2236 if self.parent.snapshot_datetime is not None: 2237 req.meta.CopyFrom(GetRequestMetadata()) 2238 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2239 2240 req.id = (id) 2241 tries = 0 2242 plumbing_response = None 2243 while True: 2244 t = None if deadline is None else deadline - time.time() 2245 try: 2246 plumbing_response = self.stub.Get( 2247 req, 2248 metadata=self.parent.get_metadata('Roles.Get', req), 2249 timeout=t) 2250 except Exception as e: 2251 if self.parent.shouldRetry(tries, e, deadline): 2252 tries += 1 2253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2254 continue 2255 raise plumbing.convert_error_to_porcelain(e) from e 2256 break 2257 2258 resp = models.RoleGetResponse() 2259 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2260 plumbing_response.meta) 2261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2262 plumbing_response.rate_limit) 2263 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2264 return resp 2265 2266 def update(self, role, timeout=None): 2267 ''' 2268 Update replaces all the fields of a Role by ID. 2269 ''' 2270 deadline = None if timeout is None else time.time() + timeout 2271 req = RoleUpdateRequest() 2272 2273 if role is not None: 2274 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2275 tries = 0 2276 plumbing_response = None 2277 while True: 2278 t = None if deadline is None else deadline - time.time() 2279 try: 2280 plumbing_response = self.stub.Update( 2281 req, 2282 metadata=self.parent.get_metadata('Roles.Update', req), 2283 timeout=t) 2284 except Exception as e: 2285 if self.parent.shouldRetry(tries, e, deadline): 2286 tries += 1 2287 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2288 continue 2289 raise plumbing.convert_error_to_porcelain(e) from e 2290 break 2291 2292 resp = models.RoleUpdateResponse() 2293 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2294 plumbing_response.meta) 2295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2296 plumbing_response.rate_limit) 2297 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2298 return resp 2299 2300 def delete(self, id, timeout=None): 2301 ''' 2302 Delete removes a Role by ID. 2303 ''' 2304 deadline = None if timeout is None else time.time() + timeout 2305 req = RoleDeleteRequest() 2306 2307 req.id = (id) 2308 tries = 0 2309 plumbing_response = None 2310 while True: 2311 t = None if deadline is None else deadline - time.time() 2312 try: 2313 plumbing_response = self.stub.Delete( 2314 req, 2315 metadata=self.parent.get_metadata('Roles.Delete', req), 2316 timeout=t) 2317 except Exception as e: 2318 if self.parent.shouldRetry(tries, e, deadline): 2319 tries += 1 2320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2321 continue 2322 raise plumbing.convert_error_to_porcelain(e) from e 2323 break 2324 2325 resp = models.RoleDeleteResponse() 2326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2327 plumbing_response.meta) 2328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2329 plumbing_response.rate_limit) 2330 return resp 2331 2332 def list(self, filter, *args, timeout=None): 2333 ''' 2334 List gets a list of Roles matching a given set of criteria. 2335 ''' 2336 deadline = None if timeout is None else time.time() + timeout 2337 req = RoleListRequest() 2338 req.meta.CopyFrom(ListRequestMetadata()) 2339 if self.parent.page_limit > 0: 2340 req.meta.limit = self.parent.page_limit 2341 if self.parent.snapshot_datetime is not None: 2342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2343 2344 req.filter = plumbing.quote_filter_args(filter, *args) 2345 2346 def generator(svc, req): 2347 tries = 0 2348 while True: 2349 t = None if deadline is None else deadline - time.time() 2350 try: 2351 plumbing_response = svc.stub.List( 2352 req, 2353 metadata=svc.parent.get_metadata('Roles.List', req), 2354 timeout=t) 2355 except Exception as e: 2356 if self.parent.shouldRetry(tries, e, deadline): 2357 tries += 1 2358 time.sleep( 2359 self.parent.exponentialBackoff(tries, deadline)) 2360 continue 2361 raise plumbing.convert_error_to_porcelain(e) from e 2362 tries = 0 2363 for plumbing_item in plumbing_response.roles: 2364 yield plumbing.convert_role_to_porcelain(plumbing_item) 2365 if plumbing_response.meta.next_cursor == '': 2366 break 2367 req.meta.cursor = plumbing_response.meta.next_cursor 2368 2369 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)
2196 def create(self, role, timeout=None): 2197 ''' 2198 Create registers a new Role. 2199 ''' 2200 deadline = None if timeout is None else time.time() + timeout 2201 req = RoleCreateRequest() 2202 2203 if role is not None: 2204 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2205 tries = 0 2206 plumbing_response = None 2207 while True: 2208 t = None if deadline is None else deadline - time.time() 2209 try: 2210 plumbing_response = self.stub.Create( 2211 req, 2212 metadata=self.parent.get_metadata('Roles.Create', req), 2213 timeout=t) 2214 except Exception as e: 2215 if self.parent.shouldRetry(tries, e, deadline): 2216 tries += 1 2217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2218 continue 2219 raise plumbing.convert_error_to_porcelain(e) from e 2220 break 2221 2222 resp = models.RoleCreateResponse() 2223 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2224 plumbing_response.meta) 2225 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2226 plumbing_response.rate_limit) 2227 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2228 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2230 def get(self, id, timeout=None): 2231 ''' 2232 Get reads one Role by ID. 2233 ''' 2234 deadline = None if timeout is None else time.time() + timeout 2235 req = RoleGetRequest() 2236 if self.parent.snapshot_datetime is not None: 2237 req.meta.CopyFrom(GetRequestMetadata()) 2238 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2239 2240 req.id = (id) 2241 tries = 0 2242 plumbing_response = None 2243 while True: 2244 t = None if deadline is None else deadline - time.time() 2245 try: 2246 plumbing_response = self.stub.Get( 2247 req, 2248 metadata=self.parent.get_metadata('Roles.Get', req), 2249 timeout=t) 2250 except Exception as e: 2251 if self.parent.shouldRetry(tries, e, deadline): 2252 tries += 1 2253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2254 continue 2255 raise plumbing.convert_error_to_porcelain(e) from e 2256 break 2257 2258 resp = models.RoleGetResponse() 2259 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2260 plumbing_response.meta) 2261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2262 plumbing_response.rate_limit) 2263 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2264 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2266 def update(self, role, timeout=None): 2267 ''' 2268 Update replaces all the fields of a Role by ID. 2269 ''' 2270 deadline = None if timeout is None else time.time() + timeout 2271 req = RoleUpdateRequest() 2272 2273 if role is not None: 2274 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2275 tries = 0 2276 plumbing_response = None 2277 while True: 2278 t = None if deadline is None else deadline - time.time() 2279 try: 2280 plumbing_response = self.stub.Update( 2281 req, 2282 metadata=self.parent.get_metadata('Roles.Update', req), 2283 timeout=t) 2284 except Exception as e: 2285 if self.parent.shouldRetry(tries, e, deadline): 2286 tries += 1 2287 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2288 continue 2289 raise plumbing.convert_error_to_porcelain(e) from e 2290 break 2291 2292 resp = models.RoleUpdateResponse() 2293 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2294 plumbing_response.meta) 2295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2296 plumbing_response.rate_limit) 2297 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2298 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
2300 def delete(self, id, timeout=None): 2301 ''' 2302 Delete removes a Role by ID. 2303 ''' 2304 deadline = None if timeout is None else time.time() + timeout 2305 req = RoleDeleteRequest() 2306 2307 req.id = (id) 2308 tries = 0 2309 plumbing_response = None 2310 while True: 2311 t = None if deadline is None else deadline - time.time() 2312 try: 2313 plumbing_response = self.stub.Delete( 2314 req, 2315 metadata=self.parent.get_metadata('Roles.Delete', req), 2316 timeout=t) 2317 except Exception as e: 2318 if self.parent.shouldRetry(tries, e, deadline): 2319 tries += 1 2320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2321 continue 2322 raise plumbing.convert_error_to_porcelain(e) from e 2323 break 2324 2325 resp = models.RoleDeleteResponse() 2326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2327 plumbing_response.meta) 2328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2329 plumbing_response.rate_limit) 2330 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
2332 def list(self, filter, *args, timeout=None): 2333 ''' 2334 List gets a list of Roles matching a given set of criteria. 2335 ''' 2336 deadline = None if timeout is None else time.time() + timeout 2337 req = RoleListRequest() 2338 req.meta.CopyFrom(ListRequestMetadata()) 2339 if self.parent.page_limit > 0: 2340 req.meta.limit = self.parent.page_limit 2341 if self.parent.snapshot_datetime is not None: 2342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2343 2344 req.filter = plumbing.quote_filter_args(filter, *args) 2345 2346 def generator(svc, req): 2347 tries = 0 2348 while True: 2349 t = None if deadline is None else deadline - time.time() 2350 try: 2351 plumbing_response = svc.stub.List( 2352 req, 2353 metadata=svc.parent.get_metadata('Roles.List', req), 2354 timeout=t) 2355 except Exception as e: 2356 if self.parent.shouldRetry(tries, e, deadline): 2357 tries += 1 2358 time.sleep( 2359 self.parent.exponentialBackoff(tries, deadline)) 2360 continue 2361 raise plumbing.convert_error_to_porcelain(e) from e 2362 tries = 0 2363 for plumbing_item in plumbing_response.roles: 2364 yield plumbing.convert_role_to_porcelain(plumbing_item) 2365 if plumbing_response.meta.next_cursor == '': 2366 break 2367 req.meta.cursor = plumbing_response.meta.next_cursor 2368 2369 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
2372class SnapshotRoles: 2373 ''' 2374 SnapshotRoles exposes the read only methods of the Roles 2375 service for historical queries. 2376 ''' 2377 def __init__(self, roles): 2378 self.roles = roles 2379 2380 def get(self, id, timeout=None): 2381 ''' 2382 Get reads one Role by ID. 2383 ''' 2384 return self.roles.get(id, timeout=timeout) 2385 2386 def list(self, filter, *args, timeout=None): 2387 ''' 2388 List gets a list of Roles matching a given set of criteria. 2389 ''' 2390 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
HealthChecks:
2393class HealthChecks: 2394 ''' 2395 HealthChecks lists the last healthcheck between each node and resource. 2396 Note the unconventional capitalization here is to prevent having a collision with GRPC 2397 See `strongdm.models.Healthcheck`. 2398 ''' 2399 def __init__(self, channel, client): 2400 self.parent = client 2401 self.stub = HealthChecksStub(channel) 2402 2403 def list(self, filter, *args, timeout=None): 2404 ''' 2405 List gets a list of Healthchecks matching a given set of criteria. 2406 ''' 2407 deadline = None if timeout is None else time.time() + timeout 2408 req = HealthcheckListRequest() 2409 req.meta.CopyFrom(ListRequestMetadata()) 2410 if self.parent.page_limit > 0: 2411 req.meta.limit = self.parent.page_limit 2412 if self.parent.snapshot_datetime is not None: 2413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2414 2415 req.filter = plumbing.quote_filter_args(filter, *args) 2416 2417 def generator(svc, req): 2418 tries = 0 2419 while True: 2420 t = None if deadline is None else deadline - time.time() 2421 try: 2422 plumbing_response = svc.stub.List( 2423 req, 2424 metadata=svc.parent.get_metadata( 2425 'HealthChecks.List', req), 2426 timeout=t) 2427 except Exception as e: 2428 if self.parent.shouldRetry(tries, e, deadline): 2429 tries += 1 2430 time.sleep( 2431 self.parent.exponentialBackoff(tries, deadline)) 2432 continue 2433 raise plumbing.convert_error_to_porcelain(e) from e 2434 tries = 0 2435 for plumbing_item in plumbing_response.healthchecks: 2436 yield plumbing.convert_healthcheck_to_porcelain( 2437 plumbing_item) 2438 if plumbing_response.meta.next_cursor == '': 2439 break 2440 req.meta.cursor = plumbing_response.meta.next_cursor 2441 2442 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)
2403 def list(self, filter, *args, timeout=None): 2404 ''' 2405 List gets a list of Healthchecks matching a given set of criteria. 2406 ''' 2407 deadline = None if timeout is None else time.time() + timeout 2408 req = HealthcheckListRequest() 2409 req.meta.CopyFrom(ListRequestMetadata()) 2410 if self.parent.page_limit > 0: 2411 req.meta.limit = self.parent.page_limit 2412 if self.parent.snapshot_datetime is not None: 2413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2414 2415 req.filter = plumbing.quote_filter_args(filter, *args) 2416 2417 def generator(svc, req): 2418 tries = 0 2419 while True: 2420 t = None if deadline is None else deadline - time.time() 2421 try: 2422 plumbing_response = svc.stub.List( 2423 req, 2424 metadata=svc.parent.get_metadata( 2425 'HealthChecks.List', req), 2426 timeout=t) 2427 except Exception as e: 2428 if self.parent.shouldRetry(tries, e, deadline): 2429 tries += 1 2430 time.sleep( 2431 self.parent.exponentialBackoff(tries, deadline)) 2432 continue 2433 raise plumbing.convert_error_to_porcelain(e) from e 2434 tries = 0 2435 for plumbing_item in plumbing_response.healthchecks: 2436 yield plumbing.convert_healthcheck_to_porcelain( 2437 plumbing_item) 2438 if plumbing_response.meta.next_cursor == '': 2439 break 2440 req.meta.cursor = plumbing_response.meta.next_cursor 2441 2442 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
2445class IdentityAliases: 2446 ''' 2447 IdentityAliases assign an alias to an account within an IdentitySet. 2448 The alias is used as the username when connecting to a identity supported resource. 2449 See `strongdm.models.IdentityAlias`. 2450 ''' 2451 def __init__(self, channel, client): 2452 self.parent = client 2453 self.stub = IdentityAliasesStub(channel) 2454 2455 def create(self, identity_alias, timeout=None): 2456 ''' 2457 Create registers a new IdentityAlias. 2458 ''' 2459 deadline = None if timeout is None else time.time() + timeout 2460 req = IdentityAliasCreateRequest() 2461 2462 if identity_alias is not None: 2463 req.identity_alias.CopyFrom( 2464 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2465 tries = 0 2466 plumbing_response = None 2467 while True: 2468 t = None if deadline is None else deadline - time.time() 2469 try: 2470 plumbing_response = self.stub.Create( 2471 req, 2472 metadata=self.parent.get_metadata('IdentityAliases.Create', 2473 req), 2474 timeout=t) 2475 except Exception as e: 2476 if self.parent.shouldRetry(tries, e, deadline): 2477 tries += 1 2478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2479 continue 2480 raise plumbing.convert_error_to_porcelain(e) from e 2481 break 2482 2483 resp = models.IdentityAliasCreateResponse() 2484 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2485 plumbing_response.identity_alias) 2486 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2487 plumbing_response.meta) 2488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2489 plumbing_response.rate_limit) 2490 return resp 2491 2492 def get(self, id, timeout=None): 2493 ''' 2494 Get reads one IdentityAlias by ID. 2495 ''' 2496 deadline = None if timeout is None else time.time() + timeout 2497 req = IdentityAliasGetRequest() 2498 if self.parent.snapshot_datetime is not None: 2499 req.meta.CopyFrom(GetRequestMetadata()) 2500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2501 2502 req.id = (id) 2503 tries = 0 2504 plumbing_response = None 2505 while True: 2506 t = None if deadline is None else deadline - time.time() 2507 try: 2508 plumbing_response = self.stub.Get( 2509 req, 2510 metadata=self.parent.get_metadata('IdentityAliases.Get', 2511 req), 2512 timeout=t) 2513 except Exception as e: 2514 if self.parent.shouldRetry(tries, e, deadline): 2515 tries += 1 2516 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2517 continue 2518 raise plumbing.convert_error_to_porcelain(e) from e 2519 break 2520 2521 resp = models.IdentityAliasGetResponse() 2522 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2523 plumbing_response.identity_alias) 2524 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2525 plumbing_response.meta) 2526 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2527 plumbing_response.rate_limit) 2528 return resp 2529 2530 def update(self, identity_alias, timeout=None): 2531 ''' 2532 Update replaces all the fields of a IdentityAlias by ID. 2533 ''' 2534 deadline = None if timeout is None else time.time() + timeout 2535 req = IdentityAliasUpdateRequest() 2536 2537 if identity_alias is not None: 2538 req.identity_alias.CopyFrom( 2539 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2540 tries = 0 2541 plumbing_response = None 2542 while True: 2543 t = None if deadline is None else deadline - time.time() 2544 try: 2545 plumbing_response = self.stub.Update( 2546 req, 2547 metadata=self.parent.get_metadata('IdentityAliases.Update', 2548 req), 2549 timeout=t) 2550 except Exception as e: 2551 if self.parent.shouldRetry(tries, e, deadline): 2552 tries += 1 2553 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2554 continue 2555 raise plumbing.convert_error_to_porcelain(e) from e 2556 break 2557 2558 resp = models.IdentityAliasUpdateResponse() 2559 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2560 plumbing_response.identity_alias) 2561 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2562 plumbing_response.meta) 2563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2564 plumbing_response.rate_limit) 2565 return resp 2566 2567 def delete(self, id, timeout=None): 2568 ''' 2569 Delete removes a IdentityAlias by ID. 2570 ''' 2571 deadline = None if timeout is None else time.time() + timeout 2572 req = IdentityAliasDeleteRequest() 2573 2574 req.id = (id) 2575 tries = 0 2576 plumbing_response = None 2577 while True: 2578 t = None if deadline is None else deadline - time.time() 2579 try: 2580 plumbing_response = self.stub.Delete( 2581 req, 2582 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2583 req), 2584 timeout=t) 2585 except Exception as e: 2586 if self.parent.shouldRetry(tries, e, deadline): 2587 tries += 1 2588 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2589 continue 2590 raise plumbing.convert_error_to_porcelain(e) from e 2591 break 2592 2593 resp = models.IdentityAliasDeleteResponse() 2594 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2595 plumbing_response.meta) 2596 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2597 plumbing_response.rate_limit) 2598 return resp 2599 2600 def list(self, filter, *args, timeout=None): 2601 ''' 2602 List gets a list of IdentityAliases matching a given set of criteria. 2603 ''' 2604 deadline = None if timeout is None else time.time() + timeout 2605 req = IdentityAliasListRequest() 2606 req.meta.CopyFrom(ListRequestMetadata()) 2607 if self.parent.page_limit > 0: 2608 req.meta.limit = self.parent.page_limit 2609 if self.parent.snapshot_datetime is not None: 2610 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2611 2612 req.filter = plumbing.quote_filter_args(filter, *args) 2613 2614 def generator(svc, req): 2615 tries = 0 2616 while True: 2617 t = None if deadline is None else deadline - time.time() 2618 try: 2619 plumbing_response = svc.stub.List( 2620 req, 2621 metadata=svc.parent.get_metadata( 2622 'IdentityAliases.List', req), 2623 timeout=t) 2624 except Exception as e: 2625 if self.parent.shouldRetry(tries, e, deadline): 2626 tries += 1 2627 time.sleep( 2628 self.parent.exponentialBackoff(tries, deadline)) 2629 continue 2630 raise plumbing.convert_error_to_porcelain(e) from e 2631 tries = 0 2632 for plumbing_item in plumbing_response.identity_aliases: 2633 yield plumbing.convert_identity_alias_to_porcelain( 2634 plumbing_item) 2635 if plumbing_response.meta.next_cursor == '': 2636 break 2637 req.meta.cursor = plumbing_response.meta.next_cursor 2638 2639 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)
2455 def create(self, identity_alias, timeout=None): 2456 ''' 2457 Create registers a new IdentityAlias. 2458 ''' 2459 deadline = None if timeout is None else time.time() + timeout 2460 req = IdentityAliasCreateRequest() 2461 2462 if identity_alias is not None: 2463 req.identity_alias.CopyFrom( 2464 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2465 tries = 0 2466 plumbing_response = None 2467 while True: 2468 t = None if deadline is None else deadline - time.time() 2469 try: 2470 plumbing_response = self.stub.Create( 2471 req, 2472 metadata=self.parent.get_metadata('IdentityAliases.Create', 2473 req), 2474 timeout=t) 2475 except Exception as e: 2476 if self.parent.shouldRetry(tries, e, deadline): 2477 tries += 1 2478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2479 continue 2480 raise plumbing.convert_error_to_porcelain(e) from e 2481 break 2482 2483 resp = models.IdentityAliasCreateResponse() 2484 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2485 plumbing_response.identity_alias) 2486 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2487 plumbing_response.meta) 2488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2489 plumbing_response.rate_limit) 2490 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
2492 def get(self, id, timeout=None): 2493 ''' 2494 Get reads one IdentityAlias by ID. 2495 ''' 2496 deadline = None if timeout is None else time.time() + timeout 2497 req = IdentityAliasGetRequest() 2498 if self.parent.snapshot_datetime is not None: 2499 req.meta.CopyFrom(GetRequestMetadata()) 2500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2501 2502 req.id = (id) 2503 tries = 0 2504 plumbing_response = None 2505 while True: 2506 t = None if deadline is None else deadline - time.time() 2507 try: 2508 plumbing_response = self.stub.Get( 2509 req, 2510 metadata=self.parent.get_metadata('IdentityAliases.Get', 2511 req), 2512 timeout=t) 2513 except Exception as e: 2514 if self.parent.shouldRetry(tries, e, deadline): 2515 tries += 1 2516 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2517 continue 2518 raise plumbing.convert_error_to_porcelain(e) from e 2519 break 2520 2521 resp = models.IdentityAliasGetResponse() 2522 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2523 plumbing_response.identity_alias) 2524 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2525 plumbing_response.meta) 2526 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2527 plumbing_response.rate_limit) 2528 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
2530 def update(self, identity_alias, timeout=None): 2531 ''' 2532 Update replaces all the fields of a IdentityAlias by ID. 2533 ''' 2534 deadline = None if timeout is None else time.time() + timeout 2535 req = IdentityAliasUpdateRequest() 2536 2537 if identity_alias is not None: 2538 req.identity_alias.CopyFrom( 2539 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2540 tries = 0 2541 plumbing_response = None 2542 while True: 2543 t = None if deadline is None else deadline - time.time() 2544 try: 2545 plumbing_response = self.stub.Update( 2546 req, 2547 metadata=self.parent.get_metadata('IdentityAliases.Update', 2548 req), 2549 timeout=t) 2550 except Exception as e: 2551 if self.parent.shouldRetry(tries, e, deadline): 2552 tries += 1 2553 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2554 continue 2555 raise plumbing.convert_error_to_porcelain(e) from e 2556 break 2557 2558 resp = models.IdentityAliasUpdateResponse() 2559 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2560 plumbing_response.identity_alias) 2561 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2562 plumbing_response.meta) 2563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2564 plumbing_response.rate_limit) 2565 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
2567 def delete(self, id, timeout=None): 2568 ''' 2569 Delete removes a IdentityAlias by ID. 2570 ''' 2571 deadline = None if timeout is None else time.time() + timeout 2572 req = IdentityAliasDeleteRequest() 2573 2574 req.id = (id) 2575 tries = 0 2576 plumbing_response = None 2577 while True: 2578 t = None if deadline is None else deadline - time.time() 2579 try: 2580 plumbing_response = self.stub.Delete( 2581 req, 2582 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2583 req), 2584 timeout=t) 2585 except Exception as e: 2586 if self.parent.shouldRetry(tries, e, deadline): 2587 tries += 1 2588 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2589 continue 2590 raise plumbing.convert_error_to_porcelain(e) from e 2591 break 2592 2593 resp = models.IdentityAliasDeleteResponse() 2594 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2595 plumbing_response.meta) 2596 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2597 plumbing_response.rate_limit) 2598 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2600 def list(self, filter, *args, timeout=None): 2601 ''' 2602 List gets a list of IdentityAliases matching a given set of criteria. 2603 ''' 2604 deadline = None if timeout is None else time.time() + timeout 2605 req = IdentityAliasListRequest() 2606 req.meta.CopyFrom(ListRequestMetadata()) 2607 if self.parent.page_limit > 0: 2608 req.meta.limit = self.parent.page_limit 2609 if self.parent.snapshot_datetime is not None: 2610 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2611 2612 req.filter = plumbing.quote_filter_args(filter, *args) 2613 2614 def generator(svc, req): 2615 tries = 0 2616 while True: 2617 t = None if deadline is None else deadline - time.time() 2618 try: 2619 plumbing_response = svc.stub.List( 2620 req, 2621 metadata=svc.parent.get_metadata( 2622 'IdentityAliases.List', req), 2623 timeout=t) 2624 except Exception as e: 2625 if self.parent.shouldRetry(tries, e, deadline): 2626 tries += 1 2627 time.sleep( 2628 self.parent.exponentialBackoff(tries, deadline)) 2629 continue 2630 raise plumbing.convert_error_to_porcelain(e) from e 2631 tries = 0 2632 for plumbing_item in plumbing_response.identity_aliases: 2633 yield plumbing.convert_identity_alias_to_porcelain( 2634 plumbing_item) 2635 if plumbing_response.meta.next_cursor == '': 2636 break 2637 req.meta.cursor = plumbing_response.meta.next_cursor 2638 2639 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
2642class SnapshotIdentityAliases: 2643 ''' 2644 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2645 service for historical queries. 2646 ''' 2647 def __init__(self, identity_aliases): 2648 self.identity_aliases = identity_aliases 2649 2650 def get(self, id, timeout=None): 2651 ''' 2652 Get reads one IdentityAlias by ID. 2653 ''' 2654 return self.identity_aliases.get(id, timeout=timeout) 2655 2656 def list(self, filter, *args, timeout=None): 2657 ''' 2658 List gets a list of IdentityAliases matching a given set of criteria. 2659 ''' 2660 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)
2650 def get(self, id, timeout=None): 2651 ''' 2652 Get reads one IdentityAlias by ID. 2653 ''' 2654 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2656 def list(self, filter, *args, timeout=None): 2657 ''' 2658 List gets a list of IdentityAliases matching a given set of criteria. 2659 ''' 2660 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
2663class IdentityAliasesHistory: 2664 ''' 2665 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2666 See `strongdm.models.IdentityAliasHistory`. 2667 ''' 2668 def __init__(self, channel, client): 2669 self.parent = client 2670 self.stub = IdentityAliasesHistoryStub(channel) 2671 2672 def list(self, filter, *args, timeout=None): 2673 ''' 2674 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2675 ''' 2676 deadline = None if timeout is None else time.time() + timeout 2677 req = IdentityAliasHistoryListRequest() 2678 req.meta.CopyFrom(ListRequestMetadata()) 2679 if self.parent.page_limit > 0: 2680 req.meta.limit = self.parent.page_limit 2681 if self.parent.snapshot_datetime is not None: 2682 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2683 2684 req.filter = plumbing.quote_filter_args(filter, *args) 2685 2686 def generator(svc, req): 2687 tries = 0 2688 while True: 2689 t = None if deadline is None else deadline - time.time() 2690 try: 2691 plumbing_response = svc.stub.List( 2692 req, 2693 metadata=svc.parent.get_metadata( 2694 'IdentityAliasesHistory.List', req), 2695 timeout=t) 2696 except Exception as e: 2697 if self.parent.shouldRetry(tries, e, deadline): 2698 tries += 1 2699 time.sleep( 2700 self.parent.exponentialBackoff(tries, deadline)) 2701 continue 2702 raise plumbing.convert_error_to_porcelain(e) from e 2703 tries = 0 2704 for plumbing_item in plumbing_response.history: 2705 yield plumbing.convert_identity_alias_history_to_porcelain( 2706 plumbing_item) 2707 if plumbing_response.meta.next_cursor == '': 2708 break 2709 req.meta.cursor = plumbing_response.meta.next_cursor 2710 2711 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)
2672 def list(self, filter, *args, timeout=None): 2673 ''' 2674 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2675 ''' 2676 deadline = None if timeout is None else time.time() + timeout 2677 req = IdentityAliasHistoryListRequest() 2678 req.meta.CopyFrom(ListRequestMetadata()) 2679 if self.parent.page_limit > 0: 2680 req.meta.limit = self.parent.page_limit 2681 if self.parent.snapshot_datetime is not None: 2682 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2683 2684 req.filter = plumbing.quote_filter_args(filter, *args) 2685 2686 def generator(svc, req): 2687 tries = 0 2688 while True: 2689 t = None if deadline is None else deadline - time.time() 2690 try: 2691 plumbing_response = svc.stub.List( 2692 req, 2693 metadata=svc.parent.get_metadata( 2694 'IdentityAliasesHistory.List', req), 2695 timeout=t) 2696 except Exception as e: 2697 if self.parent.shouldRetry(tries, e, deadline): 2698 tries += 1 2699 time.sleep( 2700 self.parent.exponentialBackoff(tries, deadline)) 2701 continue 2702 raise plumbing.convert_error_to_porcelain(e) from e 2703 tries = 0 2704 for plumbing_item in plumbing_response.history: 2705 yield plumbing.convert_identity_alias_history_to_porcelain( 2706 plumbing_item) 2707 if plumbing_response.meta.next_cursor == '': 2708 break 2709 req.meta.cursor = plumbing_response.meta.next_cursor 2710 2711 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
2714class IdentitySets: 2715 ''' 2716 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2717 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2718 See `strongdm.models.IdentitySet`. 2719 ''' 2720 def __init__(self, channel, client): 2721 self.parent = client 2722 self.stub = IdentitySetsStub(channel) 2723 2724 def create(self, identity_set, timeout=None): 2725 ''' 2726 Create registers a new IdentitySet. 2727 ''' 2728 deadline = None if timeout is None else time.time() + timeout 2729 req = IdentitySetCreateRequest() 2730 2731 if identity_set is not None: 2732 req.identity_set.CopyFrom( 2733 plumbing.convert_identity_set_to_plumbing(identity_set)) 2734 tries = 0 2735 plumbing_response = None 2736 while True: 2737 t = None if deadline is None else deadline - time.time() 2738 try: 2739 plumbing_response = self.stub.Create( 2740 req, 2741 metadata=self.parent.get_metadata('IdentitySets.Create', 2742 req), 2743 timeout=t) 2744 except Exception as e: 2745 if self.parent.shouldRetry(tries, e, deadline): 2746 tries += 1 2747 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2748 continue 2749 raise plumbing.convert_error_to_porcelain(e) from e 2750 break 2751 2752 resp = models.IdentitySetCreateResponse() 2753 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2754 plumbing_response.identity_set) 2755 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2756 plumbing_response.meta) 2757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2758 plumbing_response.rate_limit) 2759 return resp 2760 2761 def get(self, id, timeout=None): 2762 ''' 2763 Get reads one IdentitySet by ID. 2764 ''' 2765 deadline = None if timeout is None else time.time() + timeout 2766 req = IdentitySetGetRequest() 2767 if self.parent.snapshot_datetime is not None: 2768 req.meta.CopyFrom(GetRequestMetadata()) 2769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2770 2771 req.id = (id) 2772 tries = 0 2773 plumbing_response = None 2774 while True: 2775 t = None if deadline is None else deadline - time.time() 2776 try: 2777 plumbing_response = self.stub.Get( 2778 req, 2779 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2780 timeout=t) 2781 except Exception as e: 2782 if self.parent.shouldRetry(tries, e, deadline): 2783 tries += 1 2784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2785 continue 2786 raise plumbing.convert_error_to_porcelain(e) from e 2787 break 2788 2789 resp = models.IdentitySetGetResponse() 2790 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2791 plumbing_response.identity_set) 2792 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2793 plumbing_response.meta) 2794 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2795 plumbing_response.rate_limit) 2796 return resp 2797 2798 def update(self, identity_set, timeout=None): 2799 ''' 2800 Update replaces all the fields of a IdentitySet by ID. 2801 ''' 2802 deadline = None if timeout is None else time.time() + timeout 2803 req = IdentitySetUpdateRequest() 2804 2805 if identity_set is not None: 2806 req.identity_set.CopyFrom( 2807 plumbing.convert_identity_set_to_plumbing(identity_set)) 2808 tries = 0 2809 plumbing_response = None 2810 while True: 2811 t = None if deadline is None else deadline - time.time() 2812 try: 2813 plumbing_response = self.stub.Update( 2814 req, 2815 metadata=self.parent.get_metadata('IdentitySets.Update', 2816 req), 2817 timeout=t) 2818 except Exception as e: 2819 if self.parent.shouldRetry(tries, e, deadline): 2820 tries += 1 2821 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2822 continue 2823 raise plumbing.convert_error_to_porcelain(e) from e 2824 break 2825 2826 resp = models.IdentitySetUpdateResponse() 2827 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2828 plumbing_response.identity_set) 2829 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2830 plumbing_response.meta) 2831 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2832 plumbing_response.rate_limit) 2833 return resp 2834 2835 def delete(self, id, timeout=None): 2836 ''' 2837 Delete removes a IdentitySet by ID. 2838 ''' 2839 deadline = None if timeout is None else time.time() + timeout 2840 req = IdentitySetDeleteRequest() 2841 2842 req.id = (id) 2843 tries = 0 2844 plumbing_response = None 2845 while True: 2846 t = None if deadline is None else deadline - time.time() 2847 try: 2848 plumbing_response = self.stub.Delete( 2849 req, 2850 metadata=self.parent.get_metadata('IdentitySets.Delete', 2851 req), 2852 timeout=t) 2853 except Exception as e: 2854 if self.parent.shouldRetry(tries, e, deadline): 2855 tries += 1 2856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2857 continue 2858 raise plumbing.convert_error_to_porcelain(e) from e 2859 break 2860 2861 resp = models.IdentitySetDeleteResponse() 2862 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2863 plumbing_response.meta) 2864 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2865 plumbing_response.rate_limit) 2866 return resp 2867 2868 def list(self, filter, *args, timeout=None): 2869 ''' 2870 List gets a list of IdentitySets matching a given set of criteria. 2871 ''' 2872 deadline = None if timeout is None else time.time() + timeout 2873 req = IdentitySetListRequest() 2874 req.meta.CopyFrom(ListRequestMetadata()) 2875 if self.parent.page_limit > 0: 2876 req.meta.limit = self.parent.page_limit 2877 if self.parent.snapshot_datetime is not None: 2878 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2879 2880 req.filter = plumbing.quote_filter_args(filter, *args) 2881 2882 def generator(svc, req): 2883 tries = 0 2884 while True: 2885 t = None if deadline is None else deadline - time.time() 2886 try: 2887 plumbing_response = svc.stub.List( 2888 req, 2889 metadata=svc.parent.get_metadata( 2890 'IdentitySets.List', req), 2891 timeout=t) 2892 except Exception as e: 2893 if self.parent.shouldRetry(tries, e, deadline): 2894 tries += 1 2895 time.sleep( 2896 self.parent.exponentialBackoff(tries, deadline)) 2897 continue 2898 raise plumbing.convert_error_to_porcelain(e) from e 2899 tries = 0 2900 for plumbing_item in plumbing_response.identity_sets: 2901 yield plumbing.convert_identity_set_to_porcelain( 2902 plumbing_item) 2903 if plumbing_response.meta.next_cursor == '': 2904 break 2905 req.meta.cursor = plumbing_response.meta.next_cursor 2906 2907 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)
2724 def create(self, identity_set, timeout=None): 2725 ''' 2726 Create registers a new IdentitySet. 2727 ''' 2728 deadline = None if timeout is None else time.time() + timeout 2729 req = IdentitySetCreateRequest() 2730 2731 if identity_set is not None: 2732 req.identity_set.CopyFrom( 2733 plumbing.convert_identity_set_to_plumbing(identity_set)) 2734 tries = 0 2735 plumbing_response = None 2736 while True: 2737 t = None if deadline is None else deadline - time.time() 2738 try: 2739 plumbing_response = self.stub.Create( 2740 req, 2741 metadata=self.parent.get_metadata('IdentitySets.Create', 2742 req), 2743 timeout=t) 2744 except Exception as e: 2745 if self.parent.shouldRetry(tries, e, deadline): 2746 tries += 1 2747 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2748 continue 2749 raise plumbing.convert_error_to_porcelain(e) from e 2750 break 2751 2752 resp = models.IdentitySetCreateResponse() 2753 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2754 plumbing_response.identity_set) 2755 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2756 plumbing_response.meta) 2757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2758 plumbing_response.rate_limit) 2759 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
2761 def get(self, id, timeout=None): 2762 ''' 2763 Get reads one IdentitySet by ID. 2764 ''' 2765 deadline = None if timeout is None else time.time() + timeout 2766 req = IdentitySetGetRequest() 2767 if self.parent.snapshot_datetime is not None: 2768 req.meta.CopyFrom(GetRequestMetadata()) 2769 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2770 2771 req.id = (id) 2772 tries = 0 2773 plumbing_response = None 2774 while True: 2775 t = None if deadline is None else deadline - time.time() 2776 try: 2777 plumbing_response = self.stub.Get( 2778 req, 2779 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2780 timeout=t) 2781 except Exception as e: 2782 if self.parent.shouldRetry(tries, e, deadline): 2783 tries += 1 2784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2785 continue 2786 raise plumbing.convert_error_to_porcelain(e) from e 2787 break 2788 2789 resp = models.IdentitySetGetResponse() 2790 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2791 plumbing_response.identity_set) 2792 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2793 plumbing_response.meta) 2794 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2795 plumbing_response.rate_limit) 2796 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
2798 def update(self, identity_set, timeout=None): 2799 ''' 2800 Update replaces all the fields of a IdentitySet by ID. 2801 ''' 2802 deadline = None if timeout is None else time.time() + timeout 2803 req = IdentitySetUpdateRequest() 2804 2805 if identity_set is not None: 2806 req.identity_set.CopyFrom( 2807 plumbing.convert_identity_set_to_plumbing(identity_set)) 2808 tries = 0 2809 plumbing_response = None 2810 while True: 2811 t = None if deadline is None else deadline - time.time() 2812 try: 2813 plumbing_response = self.stub.Update( 2814 req, 2815 metadata=self.parent.get_metadata('IdentitySets.Update', 2816 req), 2817 timeout=t) 2818 except Exception as e: 2819 if self.parent.shouldRetry(tries, e, deadline): 2820 tries += 1 2821 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2822 continue 2823 raise plumbing.convert_error_to_porcelain(e) from e 2824 break 2825 2826 resp = models.IdentitySetUpdateResponse() 2827 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2828 plumbing_response.identity_set) 2829 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2830 plumbing_response.meta) 2831 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2832 plumbing_response.rate_limit) 2833 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
2835 def delete(self, id, timeout=None): 2836 ''' 2837 Delete removes a IdentitySet by ID. 2838 ''' 2839 deadline = None if timeout is None else time.time() + timeout 2840 req = IdentitySetDeleteRequest() 2841 2842 req.id = (id) 2843 tries = 0 2844 plumbing_response = None 2845 while True: 2846 t = None if deadline is None else deadline - time.time() 2847 try: 2848 plumbing_response = self.stub.Delete( 2849 req, 2850 metadata=self.parent.get_metadata('IdentitySets.Delete', 2851 req), 2852 timeout=t) 2853 except Exception as e: 2854 if self.parent.shouldRetry(tries, e, deadline): 2855 tries += 1 2856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2857 continue 2858 raise plumbing.convert_error_to_porcelain(e) from e 2859 break 2860 2861 resp = models.IdentitySetDeleteResponse() 2862 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2863 plumbing_response.meta) 2864 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2865 plumbing_response.rate_limit) 2866 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2868 def list(self, filter, *args, timeout=None): 2869 ''' 2870 List gets a list of IdentitySets matching a given set of criteria. 2871 ''' 2872 deadline = None if timeout is None else time.time() + timeout 2873 req = IdentitySetListRequest() 2874 req.meta.CopyFrom(ListRequestMetadata()) 2875 if self.parent.page_limit > 0: 2876 req.meta.limit = self.parent.page_limit 2877 if self.parent.snapshot_datetime is not None: 2878 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2879 2880 req.filter = plumbing.quote_filter_args(filter, *args) 2881 2882 def generator(svc, req): 2883 tries = 0 2884 while True: 2885 t = None if deadline is None else deadline - time.time() 2886 try: 2887 plumbing_response = svc.stub.List( 2888 req, 2889 metadata=svc.parent.get_metadata( 2890 'IdentitySets.List', req), 2891 timeout=t) 2892 except Exception as e: 2893 if self.parent.shouldRetry(tries, e, deadline): 2894 tries += 1 2895 time.sleep( 2896 self.parent.exponentialBackoff(tries, deadline)) 2897 continue 2898 raise plumbing.convert_error_to_porcelain(e) from e 2899 tries = 0 2900 for plumbing_item in plumbing_response.identity_sets: 2901 yield plumbing.convert_identity_set_to_porcelain( 2902 plumbing_item) 2903 if plumbing_response.meta.next_cursor == '': 2904 break 2905 req.meta.cursor = plumbing_response.meta.next_cursor 2906 2907 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
2910class SnapshotIdentitySets: 2911 ''' 2912 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2913 service for historical queries. 2914 ''' 2915 def __init__(self, identity_sets): 2916 self.identity_sets = identity_sets 2917 2918 def get(self, id, timeout=None): 2919 ''' 2920 Get reads one IdentitySet by ID. 2921 ''' 2922 return self.identity_sets.get(id, timeout=timeout) 2923 2924 def list(self, filter, *args, timeout=None): 2925 ''' 2926 List gets a list of IdentitySets matching a given set of criteria. 2927 ''' 2928 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)
2918 def get(self, id, timeout=None): 2919 ''' 2920 Get reads one IdentitySet by ID. 2921 ''' 2922 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2924 def list(self, filter, *args, timeout=None): 2925 ''' 2926 List gets a list of IdentitySets matching a given set of criteria. 2927 ''' 2928 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
2931class IdentitySetsHistory: 2932 ''' 2933 IdentitySetsHistory records all changes to the state of a IdentitySet. 2934 See `strongdm.models.IdentitySetHistory`. 2935 ''' 2936 def __init__(self, channel, client): 2937 self.parent = client 2938 self.stub = IdentitySetsHistoryStub(channel) 2939 2940 def list(self, filter, *args, timeout=None): 2941 ''' 2942 List gets a list of IdentitySetHistory records matching a given set of criteria. 2943 ''' 2944 deadline = None if timeout is None else time.time() + timeout 2945 req = IdentitySetHistoryListRequest() 2946 req.meta.CopyFrom(ListRequestMetadata()) 2947 if self.parent.page_limit > 0: 2948 req.meta.limit = self.parent.page_limit 2949 if self.parent.snapshot_datetime is not None: 2950 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2951 2952 req.filter = plumbing.quote_filter_args(filter, *args) 2953 2954 def generator(svc, req): 2955 tries = 0 2956 while True: 2957 t = None if deadline is None else deadline - time.time() 2958 try: 2959 plumbing_response = svc.stub.List( 2960 req, 2961 metadata=svc.parent.get_metadata( 2962 'IdentitySetsHistory.List', req), 2963 timeout=t) 2964 except Exception as e: 2965 if self.parent.shouldRetry(tries, e, deadline): 2966 tries += 1 2967 time.sleep( 2968 self.parent.exponentialBackoff(tries, deadline)) 2969 continue 2970 raise plumbing.convert_error_to_porcelain(e) from e 2971 tries = 0 2972 for plumbing_item in plumbing_response.history: 2973 yield plumbing.convert_identity_set_history_to_porcelain( 2974 plumbing_item) 2975 if plumbing_response.meta.next_cursor == '': 2976 break 2977 req.meta.cursor = plumbing_response.meta.next_cursor 2978 2979 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)
2940 def list(self, filter, *args, timeout=None): 2941 ''' 2942 List gets a list of IdentitySetHistory records matching a given set of criteria. 2943 ''' 2944 deadline = None if timeout is None else time.time() + timeout 2945 req = IdentitySetHistoryListRequest() 2946 req.meta.CopyFrom(ListRequestMetadata()) 2947 if self.parent.page_limit > 0: 2948 req.meta.limit = self.parent.page_limit 2949 if self.parent.snapshot_datetime is not None: 2950 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2951 2952 req.filter = plumbing.quote_filter_args(filter, *args) 2953 2954 def generator(svc, req): 2955 tries = 0 2956 while True: 2957 t = None if deadline is None else deadline - time.time() 2958 try: 2959 plumbing_response = svc.stub.List( 2960 req, 2961 metadata=svc.parent.get_metadata( 2962 'IdentitySetsHistory.List', req), 2963 timeout=t) 2964 except Exception as e: 2965 if self.parent.shouldRetry(tries, e, deadline): 2966 tries += 1 2967 time.sleep( 2968 self.parent.exponentialBackoff(tries, deadline)) 2969 continue 2970 raise plumbing.convert_error_to_porcelain(e) from e 2971 tries = 0 2972 for plumbing_item in plumbing_response.history: 2973 yield plumbing.convert_identity_set_history_to_porcelain( 2974 plumbing_item) 2975 if plumbing_response.meta.next_cursor == '': 2976 break 2977 req.meta.cursor = plumbing_response.meta.next_cursor 2978 2979 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
2982class ManagedSecrets: 2983 ''' 2984 ManagedSecret is a private vertical for creating, reading, updating, 2985 deleting, listing and rotating the managed secrets in the secrets engines as 2986 an authenticated user. 2987 See `strongdm.models.ManagedSecret`. 2988 ''' 2989 def __init__(self, channel, client): 2990 self.parent = client 2991 self.stub = ManagedSecretsStub(channel) 2992 2993 def list(self, filter, *args, timeout=None): 2994 ''' 2995 List returns Managed Secrets from a Secret Engine. 2996 ''' 2997 deadline = None if timeout is None else time.time() + timeout 2998 req = ManagedSecretListRequest() 2999 req.meta.CopyFrom(ListRequestMetadata()) 3000 if self.parent.page_limit > 0: 3001 req.meta.limit = self.parent.page_limit 3002 if self.parent.snapshot_datetime is not None: 3003 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3004 3005 req.filter = plumbing.quote_filter_args(filter, *args) 3006 3007 def generator(svc, req): 3008 tries = 0 3009 while True: 3010 t = None if deadline is None else deadline - time.time() 3011 try: 3012 plumbing_response = svc.stub.List( 3013 req, 3014 metadata=svc.parent.get_metadata( 3015 'ManagedSecrets.List', req), 3016 timeout=t) 3017 except Exception as e: 3018 if self.parent.shouldRetry(tries, e, deadline): 3019 tries += 1 3020 time.sleep( 3021 self.parent.exponentialBackoff(tries, deadline)) 3022 continue 3023 raise plumbing.convert_error_to_porcelain(e) from e 3024 tries = 0 3025 for plumbing_item in plumbing_response.managed_secrets: 3026 yield plumbing.convert_managed_secret_to_porcelain( 3027 plumbing_item) 3028 if plumbing_response.meta.next_cursor == '': 3029 break 3030 req.meta.cursor = plumbing_response.meta.next_cursor 3031 3032 return generator(self, req) 3033 3034 def list_by_actor(self, filter, *args, timeout=None): 3035 ''' 3036 List returns Managed Secrets for an Actor from a Secret Engine. 3037 ''' 3038 deadline = None if timeout is None else time.time() + timeout 3039 req = ManagedSecretListRequest() 3040 req.meta.CopyFrom(ListRequestMetadata()) 3041 if self.parent.page_limit > 0: 3042 req.meta.limit = self.parent.page_limit 3043 if self.parent.snapshot_datetime is not None: 3044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3045 3046 req.filter = plumbing.quote_filter_args(filter, *args) 3047 3048 def generator(svc, req): 3049 tries = 0 3050 while True: 3051 t = None if deadline is None else deadline - time.time() 3052 try: 3053 plumbing_response = svc.stub.ListByActor( 3054 req, 3055 metadata=svc.parent.get_metadata( 3056 'ManagedSecrets.ListByActor', req), 3057 timeout=t) 3058 except Exception as e: 3059 if self.parent.shouldRetry(tries, e, deadline): 3060 tries += 1 3061 time.sleep( 3062 self.parent.exponentialBackoff(tries, deadline)) 3063 continue 3064 raise plumbing.convert_error_to_porcelain(e) from e 3065 tries = 0 3066 for plumbing_item in plumbing_response.managed_secrets: 3067 yield plumbing.convert_managed_secret_to_porcelain( 3068 plumbing_item) 3069 if plumbing_response.meta.next_cursor == '': 3070 break 3071 req.meta.cursor = plumbing_response.meta.next_cursor 3072 3073 return generator(self, req) 3074 3075 def create(self, managed_secret, timeout=None): 3076 ''' 3077 Create creates a Managed Secret 3078 ''' 3079 deadline = None if timeout is None else time.time() + timeout 3080 req = ManagedSecretCreateRequest() 3081 3082 if managed_secret is not None: 3083 req.managed_secret.CopyFrom( 3084 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3085 tries = 0 3086 plumbing_response = None 3087 while True: 3088 t = None if deadline is None else deadline - time.time() 3089 try: 3090 plumbing_response = self.stub.Create( 3091 req, 3092 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3093 req), 3094 timeout=t) 3095 except Exception as e: 3096 if self.parent.shouldRetry(tries, e, deadline): 3097 tries += 1 3098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3099 continue 3100 raise plumbing.convert_error_to_porcelain(e) from e 3101 break 3102 3103 resp = models.ManagedSecretCreateResponse() 3104 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3105 plumbing_response.managed_secret) 3106 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3107 plumbing_response.meta) 3108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3109 plumbing_response.rate_limit) 3110 return resp 3111 3112 def update(self, managed_secret, timeout=None): 3113 ''' 3114 Update updates a Managed Secret 3115 ''' 3116 deadline = None if timeout is None else time.time() + timeout 3117 req = ManagedSecretUpdateRequest() 3118 3119 if managed_secret is not None: 3120 req.managed_secret.CopyFrom( 3121 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3122 tries = 0 3123 plumbing_response = None 3124 while True: 3125 t = None if deadline is None else deadline - time.time() 3126 try: 3127 plumbing_response = self.stub.Update( 3128 req, 3129 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3130 req), 3131 timeout=t) 3132 except Exception as e: 3133 if self.parent.shouldRetry(tries, e, deadline): 3134 tries += 1 3135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3136 continue 3137 raise plumbing.convert_error_to_porcelain(e) from e 3138 break 3139 3140 resp = models.ManagedSecretUpdateResponse() 3141 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3142 plumbing_response.managed_secret) 3143 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3144 plumbing_response.meta) 3145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3146 plumbing_response.rate_limit) 3147 return resp 3148 3149 def rotate(self, id, timeout=None): 3150 ''' 3151 Rotate forces rotation of Managed Secret 3152 ''' 3153 deadline = None if timeout is None else time.time() + timeout 3154 req = ManagedSecretRotateRequest() 3155 3156 req.id = (id) 3157 tries = 0 3158 plumbing_response = None 3159 while True: 3160 t = None if deadline is None else deadline - time.time() 3161 try: 3162 plumbing_response = self.stub.Rotate( 3163 req, 3164 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3165 req), 3166 timeout=t) 3167 except Exception as e: 3168 if self.parent.shouldRetry(tries, e, deadline): 3169 tries += 1 3170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3171 continue 3172 raise plumbing.convert_error_to_porcelain(e) from e 3173 break 3174 3175 resp = models.ManagedSecretRotateResponse() 3176 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3177 plumbing_response.meta) 3178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3179 plumbing_response.rate_limit) 3180 return resp 3181 3182 def delete(self, id, timeout=None): 3183 ''' 3184 Delete deletes a Managed Secret 3185 ''' 3186 deadline = None if timeout is None else time.time() + timeout 3187 req = ManagedSecretDeleteRequest() 3188 3189 req.id = (id) 3190 tries = 0 3191 plumbing_response = None 3192 while True: 3193 t = None if deadline is None else deadline - time.time() 3194 try: 3195 plumbing_response = self.stub.Delete( 3196 req, 3197 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3198 req), 3199 timeout=t) 3200 except Exception as e: 3201 if self.parent.shouldRetry(tries, e, deadline): 3202 tries += 1 3203 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3204 continue 3205 raise plumbing.convert_error_to_porcelain(e) from e 3206 break 3207 3208 resp = models.ManagedSecretDeleteResponse() 3209 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3210 plumbing_response.rate_limit) 3211 return resp 3212 3213 def force_delete(self, id, timeout=None): 3214 ''' 3215 ForceDelete deletes a Managed Secret regardless of errors on external system 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = ManagedSecretDeleteRequest() 3219 3220 req.id = (id) 3221 tries = 0 3222 plumbing_response = None 3223 while True: 3224 t = None if deadline is None else deadline - time.time() 3225 try: 3226 plumbing_response = self.stub.ForceDelete( 3227 req, 3228 metadata=self.parent.get_metadata( 3229 'ManagedSecrets.ForceDelete', req), 3230 timeout=t) 3231 except Exception as e: 3232 if self.parent.shouldRetry(tries, e, deadline): 3233 tries += 1 3234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3235 continue 3236 raise plumbing.convert_error_to_porcelain(e) from e 3237 break 3238 3239 resp = models.ManagedSecretDeleteResponse() 3240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3241 plumbing_response.rate_limit) 3242 return resp 3243 3244 def get(self, id, timeout=None): 3245 ''' 3246 Get gets details of a Managed Secret without sensitive data 3247 ''' 3248 deadline = None if timeout is None else time.time() + timeout 3249 req = ManagedSecretGetRequest() 3250 if self.parent.snapshot_datetime is not None: 3251 req.meta.CopyFrom(GetRequestMetadata()) 3252 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3253 3254 req.id = (id) 3255 tries = 0 3256 plumbing_response = None 3257 while True: 3258 t = None if deadline is None else deadline - time.time() 3259 try: 3260 plumbing_response = self.stub.Get( 3261 req, 3262 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3263 req), 3264 timeout=t) 3265 except Exception as e: 3266 if self.parent.shouldRetry(tries, e, deadline): 3267 tries += 1 3268 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3269 continue 3270 raise plumbing.convert_error_to_porcelain(e) from e 3271 break 3272 3273 resp = models.ManagedSecretGetResponse() 3274 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3275 plumbing_response.managed_secret) 3276 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3277 plumbing_response.meta) 3278 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3279 plumbing_response.rate_limit) 3280 return resp 3281 3282 def retrieve(self, id, public_key, timeout=None): 3283 ''' 3284 Retrieve returns Managed Secret with sensitive data 3285 ''' 3286 deadline = None if timeout is None else time.time() + timeout 3287 req = ManagedSecretRetrieveRequest() 3288 3289 req.id = (id) 3290 req.public_key = (public_key) 3291 tries = 0 3292 plumbing_response = None 3293 while True: 3294 t = None if deadline is None else deadline - time.time() 3295 try: 3296 plumbing_response = self.stub.Retrieve( 3297 req, 3298 metadata=self.parent.get_metadata( 3299 'ManagedSecrets.Retrieve', req), 3300 timeout=t) 3301 except Exception as e: 3302 if self.parent.shouldRetry(tries, e, deadline): 3303 tries += 1 3304 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3305 continue 3306 raise plumbing.convert_error_to_porcelain(e) from e 3307 break 3308 3309 resp = models.ManagedSecretRetrieveResponse() 3310 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3311 plumbing_response.managed_secret) 3312 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3313 plumbing_response.meta) 3314 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3315 plumbing_response.rate_limit) 3316 return resp 3317 3318 def validate(self, id, timeout=None): 3319 ''' 3320 Validate returns the result of testing the stored credential against the 3321 secret engine. 3322 ''' 3323 deadline = None if timeout is None else time.time() + timeout 3324 req = ManagedSecretValidateRequest() 3325 3326 req.id = (id) 3327 tries = 0 3328 plumbing_response = None 3329 while True: 3330 t = None if deadline is None else deadline - time.time() 3331 try: 3332 plumbing_response = self.stub.Validate( 3333 req, 3334 metadata=self.parent.get_metadata( 3335 'ManagedSecrets.Validate', req), 3336 timeout=t) 3337 except Exception as e: 3338 if self.parent.shouldRetry(tries, e, deadline): 3339 tries += 1 3340 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3341 continue 3342 raise plumbing.convert_error_to_porcelain(e) from e 3343 break 3344 3345 resp = models.ManagedSecretValidateResponse() 3346 resp.invalid_info = (plumbing_response.invalid_info) 3347 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3348 plumbing_response.meta) 3349 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3350 plumbing_response.rate_limit) 3351 resp.valid = (plumbing_response.valid) 3352 return resp 3353 3354 def logs(self, filter, *args, timeout=None): 3355 ''' 3356 Logs returns the audit records for the managed secret. This may be replaced 3357 in the future. 3358 ''' 3359 deadline = None if timeout is None else time.time() + timeout 3360 req = ManagedSecretLogsRequest() 3361 req.meta.CopyFrom(ListRequestMetadata()) 3362 if self.parent.page_limit > 0: 3363 req.meta.limit = self.parent.page_limit 3364 if self.parent.snapshot_datetime is not None: 3365 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3366 3367 req.filter = plumbing.quote_filter_args(filter, *args) 3368 3369 def generator(svc, req): 3370 tries = 0 3371 while True: 3372 t = None if deadline is None else deadline - time.time() 3373 try: 3374 plumbing_response = svc.stub.Logs( 3375 req, 3376 metadata=svc.parent.get_metadata( 3377 'ManagedSecrets.Logs', req), 3378 timeout=t) 3379 except Exception as e: 3380 if self.parent.shouldRetry(tries, e, deadline): 3381 tries += 1 3382 time.sleep( 3383 self.parent.exponentialBackoff(tries, deadline)) 3384 continue 3385 raise plumbing.convert_error_to_porcelain(e) from e 3386 tries = 0 3387 for plumbing_item in plumbing_response.managed_secret_logs: 3388 yield plumbing.convert_managed_secret_log_to_porcelain( 3389 plumbing_item) 3390 if plumbing_response.meta.next_cursor == '': 3391 break 3392 req.meta.cursor = plumbing_response.meta.next_cursor 3393 3394 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)
2993 def list(self, filter, *args, timeout=None): 2994 ''' 2995 List returns Managed Secrets from a Secret Engine. 2996 ''' 2997 deadline = None if timeout is None else time.time() + timeout 2998 req = ManagedSecretListRequest() 2999 req.meta.CopyFrom(ListRequestMetadata()) 3000 if self.parent.page_limit > 0: 3001 req.meta.limit = self.parent.page_limit 3002 if self.parent.snapshot_datetime is not None: 3003 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3004 3005 req.filter = plumbing.quote_filter_args(filter, *args) 3006 3007 def generator(svc, req): 3008 tries = 0 3009 while True: 3010 t = None if deadline is None else deadline - time.time() 3011 try: 3012 plumbing_response = svc.stub.List( 3013 req, 3014 metadata=svc.parent.get_metadata( 3015 'ManagedSecrets.List', req), 3016 timeout=t) 3017 except Exception as e: 3018 if self.parent.shouldRetry(tries, e, deadline): 3019 tries += 1 3020 time.sleep( 3021 self.parent.exponentialBackoff(tries, deadline)) 3022 continue 3023 raise plumbing.convert_error_to_porcelain(e) from e 3024 tries = 0 3025 for plumbing_item in plumbing_response.managed_secrets: 3026 yield plumbing.convert_managed_secret_to_porcelain( 3027 plumbing_item) 3028 if plumbing_response.meta.next_cursor == '': 3029 break 3030 req.meta.cursor = plumbing_response.meta.next_cursor 3031 3032 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
3034 def list_by_actor(self, filter, *args, timeout=None): 3035 ''' 3036 List returns Managed Secrets for an Actor from a Secret Engine. 3037 ''' 3038 deadline = None if timeout is None else time.time() + timeout 3039 req = ManagedSecretListRequest() 3040 req.meta.CopyFrom(ListRequestMetadata()) 3041 if self.parent.page_limit > 0: 3042 req.meta.limit = self.parent.page_limit 3043 if self.parent.snapshot_datetime is not None: 3044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3045 3046 req.filter = plumbing.quote_filter_args(filter, *args) 3047 3048 def generator(svc, req): 3049 tries = 0 3050 while True: 3051 t = None if deadline is None else deadline - time.time() 3052 try: 3053 plumbing_response = svc.stub.ListByActor( 3054 req, 3055 metadata=svc.parent.get_metadata( 3056 'ManagedSecrets.ListByActor', req), 3057 timeout=t) 3058 except Exception as e: 3059 if self.parent.shouldRetry(tries, e, deadline): 3060 tries += 1 3061 time.sleep( 3062 self.parent.exponentialBackoff(tries, deadline)) 3063 continue 3064 raise plumbing.convert_error_to_porcelain(e) from e 3065 tries = 0 3066 for plumbing_item in plumbing_response.managed_secrets: 3067 yield plumbing.convert_managed_secret_to_porcelain( 3068 plumbing_item) 3069 if plumbing_response.meta.next_cursor == '': 3070 break 3071 req.meta.cursor = plumbing_response.meta.next_cursor 3072 3073 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
3075 def create(self, managed_secret, timeout=None): 3076 ''' 3077 Create creates a Managed Secret 3078 ''' 3079 deadline = None if timeout is None else time.time() + timeout 3080 req = ManagedSecretCreateRequest() 3081 3082 if managed_secret is not None: 3083 req.managed_secret.CopyFrom( 3084 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3085 tries = 0 3086 plumbing_response = None 3087 while True: 3088 t = None if deadline is None else deadline - time.time() 3089 try: 3090 plumbing_response = self.stub.Create( 3091 req, 3092 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3093 req), 3094 timeout=t) 3095 except Exception as e: 3096 if self.parent.shouldRetry(tries, e, deadline): 3097 tries += 1 3098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3099 continue 3100 raise plumbing.convert_error_to_porcelain(e) from e 3101 break 3102 3103 resp = models.ManagedSecretCreateResponse() 3104 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3105 plumbing_response.managed_secret) 3106 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3107 plumbing_response.meta) 3108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3109 plumbing_response.rate_limit) 3110 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
3112 def update(self, managed_secret, timeout=None): 3113 ''' 3114 Update updates a Managed Secret 3115 ''' 3116 deadline = None if timeout is None else time.time() + timeout 3117 req = ManagedSecretUpdateRequest() 3118 3119 if managed_secret is not None: 3120 req.managed_secret.CopyFrom( 3121 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3122 tries = 0 3123 plumbing_response = None 3124 while True: 3125 t = None if deadline is None else deadline - time.time() 3126 try: 3127 plumbing_response = self.stub.Update( 3128 req, 3129 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3130 req), 3131 timeout=t) 3132 except Exception as e: 3133 if self.parent.shouldRetry(tries, e, deadline): 3134 tries += 1 3135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3136 continue 3137 raise plumbing.convert_error_to_porcelain(e) from e 3138 break 3139 3140 resp = models.ManagedSecretUpdateResponse() 3141 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3142 plumbing_response.managed_secret) 3143 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3144 plumbing_response.meta) 3145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3146 plumbing_response.rate_limit) 3147 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
3149 def rotate(self, id, timeout=None): 3150 ''' 3151 Rotate forces rotation of Managed Secret 3152 ''' 3153 deadline = None if timeout is None else time.time() + timeout 3154 req = ManagedSecretRotateRequest() 3155 3156 req.id = (id) 3157 tries = 0 3158 plumbing_response = None 3159 while True: 3160 t = None if deadline is None else deadline - time.time() 3161 try: 3162 plumbing_response = self.stub.Rotate( 3163 req, 3164 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3165 req), 3166 timeout=t) 3167 except Exception as e: 3168 if self.parent.shouldRetry(tries, e, deadline): 3169 tries += 1 3170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3171 continue 3172 raise plumbing.convert_error_to_porcelain(e) from e 3173 break 3174 3175 resp = models.ManagedSecretRotateResponse() 3176 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3177 plumbing_response.meta) 3178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3179 plumbing_response.rate_limit) 3180 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
3182 def delete(self, id, timeout=None): 3183 ''' 3184 Delete deletes a Managed Secret 3185 ''' 3186 deadline = None if timeout is None else time.time() + timeout 3187 req = ManagedSecretDeleteRequest() 3188 3189 req.id = (id) 3190 tries = 0 3191 plumbing_response = None 3192 while True: 3193 t = None if deadline is None else deadline - time.time() 3194 try: 3195 plumbing_response = self.stub.Delete( 3196 req, 3197 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3198 req), 3199 timeout=t) 3200 except Exception as e: 3201 if self.parent.shouldRetry(tries, e, deadline): 3202 tries += 1 3203 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3204 continue 3205 raise plumbing.convert_error_to_porcelain(e) from e 3206 break 3207 3208 resp = models.ManagedSecretDeleteResponse() 3209 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3210 plumbing_response.rate_limit) 3211 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
3213 def force_delete(self, id, timeout=None): 3214 ''' 3215 ForceDelete deletes a Managed Secret regardless of errors on external system 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = ManagedSecretDeleteRequest() 3219 3220 req.id = (id) 3221 tries = 0 3222 plumbing_response = None 3223 while True: 3224 t = None if deadline is None else deadline - time.time() 3225 try: 3226 plumbing_response = self.stub.ForceDelete( 3227 req, 3228 metadata=self.parent.get_metadata( 3229 'ManagedSecrets.ForceDelete', req), 3230 timeout=t) 3231 except Exception as e: 3232 if self.parent.shouldRetry(tries, e, deadline): 3233 tries += 1 3234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3235 continue 3236 raise plumbing.convert_error_to_porcelain(e) from e 3237 break 3238 3239 resp = models.ManagedSecretDeleteResponse() 3240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3241 plumbing_response.rate_limit) 3242 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
3244 def get(self, id, timeout=None): 3245 ''' 3246 Get gets details of a Managed Secret without sensitive data 3247 ''' 3248 deadline = None if timeout is None else time.time() + timeout 3249 req = ManagedSecretGetRequest() 3250 if self.parent.snapshot_datetime is not None: 3251 req.meta.CopyFrom(GetRequestMetadata()) 3252 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3253 3254 req.id = (id) 3255 tries = 0 3256 plumbing_response = None 3257 while True: 3258 t = None if deadline is None else deadline - time.time() 3259 try: 3260 plumbing_response = self.stub.Get( 3261 req, 3262 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3263 req), 3264 timeout=t) 3265 except Exception as e: 3266 if self.parent.shouldRetry(tries, e, deadline): 3267 tries += 1 3268 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3269 continue 3270 raise plumbing.convert_error_to_porcelain(e) from e 3271 break 3272 3273 resp = models.ManagedSecretGetResponse() 3274 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3275 plumbing_response.managed_secret) 3276 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3277 plumbing_response.meta) 3278 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3279 plumbing_response.rate_limit) 3280 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, public_key, timeout=None)
3282 def retrieve(self, id, public_key, timeout=None): 3283 ''' 3284 Retrieve returns Managed Secret with sensitive data 3285 ''' 3286 deadline = None if timeout is None else time.time() + timeout 3287 req = ManagedSecretRetrieveRequest() 3288 3289 req.id = (id) 3290 req.public_key = (public_key) 3291 tries = 0 3292 plumbing_response = None 3293 while True: 3294 t = None if deadline is None else deadline - time.time() 3295 try: 3296 plumbing_response = self.stub.Retrieve( 3297 req, 3298 metadata=self.parent.get_metadata( 3299 'ManagedSecrets.Retrieve', req), 3300 timeout=t) 3301 except Exception as e: 3302 if self.parent.shouldRetry(tries, e, deadline): 3303 tries += 1 3304 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3305 continue 3306 raise plumbing.convert_error_to_porcelain(e) from e 3307 break 3308 3309 resp = models.ManagedSecretRetrieveResponse() 3310 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3311 plumbing_response.managed_secret) 3312 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3313 plumbing_response.meta) 3314 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3315 plumbing_response.rate_limit) 3316 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
3318 def validate(self, id, timeout=None): 3319 ''' 3320 Validate returns the result of testing the stored credential against the 3321 secret engine. 3322 ''' 3323 deadline = None if timeout is None else time.time() + timeout 3324 req = ManagedSecretValidateRequest() 3325 3326 req.id = (id) 3327 tries = 0 3328 plumbing_response = None 3329 while True: 3330 t = None if deadline is None else deadline - time.time() 3331 try: 3332 plumbing_response = self.stub.Validate( 3333 req, 3334 metadata=self.parent.get_metadata( 3335 'ManagedSecrets.Validate', req), 3336 timeout=t) 3337 except Exception as e: 3338 if self.parent.shouldRetry(tries, e, deadline): 3339 tries += 1 3340 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3341 continue 3342 raise plumbing.convert_error_to_porcelain(e) from e 3343 break 3344 3345 resp = models.ManagedSecretValidateResponse() 3346 resp.invalid_info = (plumbing_response.invalid_info) 3347 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3348 plumbing_response.meta) 3349 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3350 plumbing_response.rate_limit) 3351 resp.valid = (plumbing_response.valid) 3352 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
3354 def logs(self, filter, *args, timeout=None): 3355 ''' 3356 Logs returns the audit records for the managed secret. This may be replaced 3357 in the future. 3358 ''' 3359 deadline = None if timeout is None else time.time() + timeout 3360 req = ManagedSecretLogsRequest() 3361 req.meta.CopyFrom(ListRequestMetadata()) 3362 if self.parent.page_limit > 0: 3363 req.meta.limit = self.parent.page_limit 3364 if self.parent.snapshot_datetime is not None: 3365 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3366 3367 req.filter = plumbing.quote_filter_args(filter, *args) 3368 3369 def generator(svc, req): 3370 tries = 0 3371 while True: 3372 t = None if deadline is None else deadline - time.time() 3373 try: 3374 plumbing_response = svc.stub.Logs( 3375 req, 3376 metadata=svc.parent.get_metadata( 3377 'ManagedSecrets.Logs', req), 3378 timeout=t) 3379 except Exception as e: 3380 if self.parent.shouldRetry(tries, e, deadline): 3381 tries += 1 3382 time.sleep( 3383 self.parent.exponentialBackoff(tries, deadline)) 3384 continue 3385 raise plumbing.convert_error_to_porcelain(e) from e 3386 tries = 0 3387 for plumbing_item in plumbing_response.managed_secret_logs: 3388 yield plumbing.convert_managed_secret_log_to_porcelain( 3389 plumbing_item) 3390 if plumbing_response.meta.next_cursor == '': 3391 break 3392 req.meta.cursor = plumbing_response.meta.next_cursor 3393 3394 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
3397class Nodes: 3398 ''' 3399 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3400 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3401 - **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. 3402 See: 3403 `strongdm.models.Gateway` 3404 `strongdm.models.ProxyCluster` 3405 `strongdm.models.Relay` 3406 ''' 3407 def __init__(self, channel, client): 3408 self.parent = client 3409 self.stub = NodesStub(channel) 3410 3411 def create(self, node, timeout=None): 3412 ''' 3413 Create registers a new Node. 3414 ''' 3415 deadline = None if timeout is None else time.time() + timeout 3416 req = NodeCreateRequest() 3417 3418 if node is not None: 3419 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3420 tries = 0 3421 plumbing_response = None 3422 while True: 3423 t = None if deadline is None else deadline - time.time() 3424 try: 3425 plumbing_response = self.stub.Create( 3426 req, 3427 metadata=self.parent.get_metadata('Nodes.Create', req), 3428 timeout=t) 3429 except Exception as e: 3430 if self.parent.shouldRetry(tries, e, deadline): 3431 tries += 1 3432 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3433 continue 3434 raise plumbing.convert_error_to_porcelain(e) from e 3435 break 3436 3437 resp = models.NodeCreateResponse() 3438 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3439 plumbing_response.meta) 3440 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3441 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3442 plumbing_response.rate_limit) 3443 resp.token = (plumbing_response.token) 3444 return resp 3445 3446 def get(self, id, timeout=None): 3447 ''' 3448 Get reads one Node by ID. 3449 ''' 3450 deadline = None if timeout is None else time.time() + timeout 3451 req = NodeGetRequest() 3452 if self.parent.snapshot_datetime is not None: 3453 req.meta.CopyFrom(GetRequestMetadata()) 3454 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3455 3456 req.id = (id) 3457 tries = 0 3458 plumbing_response = None 3459 while True: 3460 t = None if deadline is None else deadline - time.time() 3461 try: 3462 plumbing_response = self.stub.Get( 3463 req, 3464 metadata=self.parent.get_metadata('Nodes.Get', req), 3465 timeout=t) 3466 except Exception as e: 3467 if self.parent.shouldRetry(tries, e, deadline): 3468 tries += 1 3469 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3470 continue 3471 raise plumbing.convert_error_to_porcelain(e) from e 3472 break 3473 3474 resp = models.NodeGetResponse() 3475 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3476 plumbing_response.meta) 3477 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3479 plumbing_response.rate_limit) 3480 return resp 3481 3482 def update(self, node, timeout=None): 3483 ''' 3484 Update replaces all the fields of a Node by ID. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = NodeUpdateRequest() 3488 3489 if node is not None: 3490 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 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.Update( 3497 req, 3498 metadata=self.parent.get_metadata('Nodes.Update', req), 3499 timeout=t) 3500 except Exception as e: 3501 if self.parent.shouldRetry(tries, e, deadline): 3502 tries += 1 3503 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3504 continue 3505 raise plumbing.convert_error_to_porcelain(e) from e 3506 break 3507 3508 resp = models.NodeUpdateResponse() 3509 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3510 plumbing_response.meta) 3511 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3513 plumbing_response.rate_limit) 3514 return resp 3515 3516 def delete(self, id, timeout=None): 3517 ''' 3518 Delete removes a Node by ID. 3519 ''' 3520 deadline = None if timeout is None else time.time() + timeout 3521 req = NodeDeleteRequest() 3522 3523 req.id = (id) 3524 tries = 0 3525 plumbing_response = None 3526 while True: 3527 t = None if deadline is None else deadline - time.time() 3528 try: 3529 plumbing_response = self.stub.Delete( 3530 req, 3531 metadata=self.parent.get_metadata('Nodes.Delete', req), 3532 timeout=t) 3533 except Exception as e: 3534 if self.parent.shouldRetry(tries, e, deadline): 3535 tries += 1 3536 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3537 continue 3538 raise plumbing.convert_error_to_porcelain(e) from e 3539 break 3540 3541 resp = models.NodeDeleteResponse() 3542 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3543 plumbing_response.meta) 3544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3545 plumbing_response.rate_limit) 3546 return resp 3547 3548 def list(self, filter, *args, timeout=None): 3549 ''' 3550 List gets a list of Nodes matching a given set of criteria. 3551 ''' 3552 deadline = None if timeout is None else time.time() + timeout 3553 req = NodeListRequest() 3554 req.meta.CopyFrom(ListRequestMetadata()) 3555 if self.parent.page_limit > 0: 3556 req.meta.limit = self.parent.page_limit 3557 if self.parent.snapshot_datetime is not None: 3558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3559 3560 req.filter = plumbing.quote_filter_args(filter, *args) 3561 3562 def generator(svc, req): 3563 tries = 0 3564 while True: 3565 t = None if deadline is None else deadline - time.time() 3566 try: 3567 plumbing_response = svc.stub.List( 3568 req, 3569 metadata=svc.parent.get_metadata('Nodes.List', req), 3570 timeout=t) 3571 except Exception as e: 3572 if self.parent.shouldRetry(tries, e, deadline): 3573 tries += 1 3574 time.sleep( 3575 self.parent.exponentialBackoff(tries, deadline)) 3576 continue 3577 raise plumbing.convert_error_to_porcelain(e) from e 3578 tries = 0 3579 for plumbing_item in plumbing_response.nodes: 3580 yield plumbing.convert_node_to_porcelain(plumbing_item) 3581 if plumbing_response.meta.next_cursor == '': 3582 break 3583 req.meta.cursor = plumbing_response.meta.next_cursor 3584 3585 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)
3411 def create(self, node, timeout=None): 3412 ''' 3413 Create registers a new Node. 3414 ''' 3415 deadline = None if timeout is None else time.time() + timeout 3416 req = NodeCreateRequest() 3417 3418 if node is not None: 3419 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3420 tries = 0 3421 plumbing_response = None 3422 while True: 3423 t = None if deadline is None else deadline - time.time() 3424 try: 3425 plumbing_response = self.stub.Create( 3426 req, 3427 metadata=self.parent.get_metadata('Nodes.Create', req), 3428 timeout=t) 3429 except Exception as e: 3430 if self.parent.shouldRetry(tries, e, deadline): 3431 tries += 1 3432 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3433 continue 3434 raise plumbing.convert_error_to_porcelain(e) from e 3435 break 3436 3437 resp = models.NodeCreateResponse() 3438 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3439 plumbing_response.meta) 3440 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3441 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3442 plumbing_response.rate_limit) 3443 resp.token = (plumbing_response.token) 3444 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
3446 def get(self, id, timeout=None): 3447 ''' 3448 Get reads one Node by ID. 3449 ''' 3450 deadline = None if timeout is None else time.time() + timeout 3451 req = NodeGetRequest() 3452 if self.parent.snapshot_datetime is not None: 3453 req.meta.CopyFrom(GetRequestMetadata()) 3454 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3455 3456 req.id = (id) 3457 tries = 0 3458 plumbing_response = None 3459 while True: 3460 t = None if deadline is None else deadline - time.time() 3461 try: 3462 plumbing_response = self.stub.Get( 3463 req, 3464 metadata=self.parent.get_metadata('Nodes.Get', req), 3465 timeout=t) 3466 except Exception as e: 3467 if self.parent.shouldRetry(tries, e, deadline): 3468 tries += 1 3469 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3470 continue 3471 raise plumbing.convert_error_to_porcelain(e) from e 3472 break 3473 3474 resp = models.NodeGetResponse() 3475 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3476 plumbing_response.meta) 3477 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3479 plumbing_response.rate_limit) 3480 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
3482 def update(self, node, timeout=None): 3483 ''' 3484 Update replaces all the fields of a Node by ID. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = NodeUpdateRequest() 3488 3489 if node is not None: 3490 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 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.Update( 3497 req, 3498 metadata=self.parent.get_metadata('Nodes.Update', req), 3499 timeout=t) 3500 except Exception as e: 3501 if self.parent.shouldRetry(tries, e, deadline): 3502 tries += 1 3503 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3504 continue 3505 raise plumbing.convert_error_to_porcelain(e) from e 3506 break 3507 3508 resp = models.NodeUpdateResponse() 3509 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3510 plumbing_response.meta) 3511 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3513 plumbing_response.rate_limit) 3514 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
3516 def delete(self, id, timeout=None): 3517 ''' 3518 Delete removes a Node by ID. 3519 ''' 3520 deadline = None if timeout is None else time.time() + timeout 3521 req = NodeDeleteRequest() 3522 3523 req.id = (id) 3524 tries = 0 3525 plumbing_response = None 3526 while True: 3527 t = None if deadline is None else deadline - time.time() 3528 try: 3529 plumbing_response = self.stub.Delete( 3530 req, 3531 metadata=self.parent.get_metadata('Nodes.Delete', req), 3532 timeout=t) 3533 except Exception as e: 3534 if self.parent.shouldRetry(tries, e, deadline): 3535 tries += 1 3536 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3537 continue 3538 raise plumbing.convert_error_to_porcelain(e) from e 3539 break 3540 3541 resp = models.NodeDeleteResponse() 3542 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3543 plumbing_response.meta) 3544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3545 plumbing_response.rate_limit) 3546 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
3548 def list(self, filter, *args, timeout=None): 3549 ''' 3550 List gets a list of Nodes matching a given set of criteria. 3551 ''' 3552 deadline = None if timeout is None else time.time() + timeout 3553 req = NodeListRequest() 3554 req.meta.CopyFrom(ListRequestMetadata()) 3555 if self.parent.page_limit > 0: 3556 req.meta.limit = self.parent.page_limit 3557 if self.parent.snapshot_datetime is not None: 3558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3559 3560 req.filter = plumbing.quote_filter_args(filter, *args) 3561 3562 def generator(svc, req): 3563 tries = 0 3564 while True: 3565 t = None if deadline is None else deadline - time.time() 3566 try: 3567 plumbing_response = svc.stub.List( 3568 req, 3569 metadata=svc.parent.get_metadata('Nodes.List', req), 3570 timeout=t) 3571 except Exception as e: 3572 if self.parent.shouldRetry(tries, e, deadline): 3573 tries += 1 3574 time.sleep( 3575 self.parent.exponentialBackoff(tries, deadline)) 3576 continue 3577 raise plumbing.convert_error_to_porcelain(e) from e 3578 tries = 0 3579 for plumbing_item in plumbing_response.nodes: 3580 yield plumbing.convert_node_to_porcelain(plumbing_item) 3581 if plumbing_response.meta.next_cursor == '': 3582 break 3583 req.meta.cursor = plumbing_response.meta.next_cursor 3584 3585 return generator(self, req)
List gets a list of Nodes matching a given set of criteria.
class
SnapshotNodes:
3588class SnapshotNodes: 3589 ''' 3590 SnapshotNodes exposes the read only methods of the Nodes 3591 service for historical queries. 3592 ''' 3593 def __init__(self, nodes): 3594 self.nodes = nodes 3595 3596 def get(self, id, timeout=None): 3597 ''' 3598 Get reads one Node by ID. 3599 ''' 3600 return self.nodes.get(id, timeout=timeout) 3601 3602 def list(self, filter, *args, timeout=None): 3603 ''' 3604 List gets a list of Nodes matching a given set of criteria. 3605 ''' 3606 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
3609class NodesHistory: 3610 ''' 3611 NodesHistory records all changes to the state of a Node. 3612 See `strongdm.models.NodeHistory`. 3613 ''' 3614 def __init__(self, channel, client): 3615 self.parent = client 3616 self.stub = NodesHistoryStub(channel) 3617 3618 def list(self, filter, *args, timeout=None): 3619 ''' 3620 List gets a list of NodeHistory records matching a given set of criteria. 3621 ''' 3622 deadline = None if timeout is None else time.time() + timeout 3623 req = NodeHistoryListRequest() 3624 req.meta.CopyFrom(ListRequestMetadata()) 3625 if self.parent.page_limit > 0: 3626 req.meta.limit = self.parent.page_limit 3627 if self.parent.snapshot_datetime is not None: 3628 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3629 3630 req.filter = plumbing.quote_filter_args(filter, *args) 3631 3632 def generator(svc, req): 3633 tries = 0 3634 while True: 3635 t = None if deadline is None else deadline - time.time() 3636 try: 3637 plumbing_response = svc.stub.List( 3638 req, 3639 metadata=svc.parent.get_metadata( 3640 'NodesHistory.List', req), 3641 timeout=t) 3642 except Exception as e: 3643 if self.parent.shouldRetry(tries, e, deadline): 3644 tries += 1 3645 time.sleep( 3646 self.parent.exponentialBackoff(tries, deadline)) 3647 continue 3648 raise plumbing.convert_error_to_porcelain(e) from e 3649 tries = 0 3650 for plumbing_item in plumbing_response.history: 3651 yield plumbing.convert_node_history_to_porcelain( 3652 plumbing_item) 3653 if plumbing_response.meta.next_cursor == '': 3654 break 3655 req.meta.cursor = plumbing_response.meta.next_cursor 3656 3657 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)
3618 def list(self, filter, *args, timeout=None): 3619 ''' 3620 List gets a list of NodeHistory records matching a given set of criteria. 3621 ''' 3622 deadline = None if timeout is None else time.time() + timeout 3623 req = NodeHistoryListRequest() 3624 req.meta.CopyFrom(ListRequestMetadata()) 3625 if self.parent.page_limit > 0: 3626 req.meta.limit = self.parent.page_limit 3627 if self.parent.snapshot_datetime is not None: 3628 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3629 3630 req.filter = plumbing.quote_filter_args(filter, *args) 3631 3632 def generator(svc, req): 3633 tries = 0 3634 while True: 3635 t = None if deadline is None else deadline - time.time() 3636 try: 3637 plumbing_response = svc.stub.List( 3638 req, 3639 metadata=svc.parent.get_metadata( 3640 'NodesHistory.List', req), 3641 timeout=t) 3642 except Exception as e: 3643 if self.parent.shouldRetry(tries, e, deadline): 3644 tries += 1 3645 time.sleep( 3646 self.parent.exponentialBackoff(tries, deadline)) 3647 continue 3648 raise plumbing.convert_error_to_porcelain(e) from e 3649 tries = 0 3650 for plumbing_item in plumbing_response.history: 3651 yield plumbing.convert_node_history_to_porcelain( 3652 plumbing_item) 3653 if plumbing_response.meta.next_cursor == '': 3654 break 3655 req.meta.cursor = plumbing_response.meta.next_cursor 3656 3657 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
3660class OrganizationHistory: 3661 ''' 3662 OrganizationHistory records all changes to the state of an Organization. 3663 See `strongdm.models.OrganizationHistoryRecord`. 3664 ''' 3665 def __init__(self, channel, client): 3666 self.parent = client 3667 self.stub = OrganizationHistoryStub(channel) 3668 3669 def list(self, filter, *args, timeout=None): 3670 ''' 3671 List gets a list of OrganizationHistory records matching a given set of criteria. 3672 ''' 3673 deadline = None if timeout is None else time.time() + timeout 3674 req = OrganizationHistoryListRequest() 3675 req.meta.CopyFrom(ListRequestMetadata()) 3676 if self.parent.page_limit > 0: 3677 req.meta.limit = self.parent.page_limit 3678 if self.parent.snapshot_datetime is not None: 3679 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3680 3681 req.filter = plumbing.quote_filter_args(filter, *args) 3682 3683 def generator(svc, req): 3684 tries = 0 3685 while True: 3686 t = None if deadline is None else deadline - time.time() 3687 try: 3688 plumbing_response = svc.stub.List( 3689 req, 3690 metadata=svc.parent.get_metadata( 3691 'OrganizationHistory.List', req), 3692 timeout=t) 3693 except Exception as e: 3694 if self.parent.shouldRetry(tries, e, deadline): 3695 tries += 1 3696 time.sleep( 3697 self.parent.exponentialBackoff(tries, deadline)) 3698 continue 3699 raise plumbing.convert_error_to_porcelain(e) from e 3700 tries = 0 3701 for plumbing_item in plumbing_response.history: 3702 yield plumbing.convert_organization_history_record_to_porcelain( 3703 plumbing_item) 3704 if plumbing_response.meta.next_cursor == '': 3705 break 3706 req.meta.cursor = plumbing_response.meta.next_cursor 3707 3708 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)
3669 def list(self, filter, *args, timeout=None): 3670 ''' 3671 List gets a list of OrganizationHistory records matching a given set of criteria. 3672 ''' 3673 deadline = None if timeout is None else time.time() + timeout 3674 req = OrganizationHistoryListRequest() 3675 req.meta.CopyFrom(ListRequestMetadata()) 3676 if self.parent.page_limit > 0: 3677 req.meta.limit = self.parent.page_limit 3678 if self.parent.snapshot_datetime is not None: 3679 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3680 3681 req.filter = plumbing.quote_filter_args(filter, *args) 3682 3683 def generator(svc, req): 3684 tries = 0 3685 while True: 3686 t = None if deadline is None else deadline - time.time() 3687 try: 3688 plumbing_response = svc.stub.List( 3689 req, 3690 metadata=svc.parent.get_metadata( 3691 'OrganizationHistory.List', req), 3692 timeout=t) 3693 except Exception as e: 3694 if self.parent.shouldRetry(tries, e, deadline): 3695 tries += 1 3696 time.sleep( 3697 self.parent.exponentialBackoff(tries, deadline)) 3698 continue 3699 raise plumbing.convert_error_to_porcelain(e) from e 3700 tries = 0 3701 for plumbing_item in plumbing_response.history: 3702 yield plumbing.convert_organization_history_record_to_porcelain( 3703 plumbing_item) 3704 if plumbing_response.meta.next_cursor == '': 3705 break 3706 req.meta.cursor = plumbing_response.meta.next_cursor 3707 3708 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
3711class PeeringGroupNodes: 3712 ''' 3713 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3714 See `strongdm.models.PeeringGroupNode`. 3715 ''' 3716 def __init__(self, channel, client): 3717 self.parent = client 3718 self.stub = PeeringGroupNodesStub(channel) 3719 3720 def create(self, peering_group_node, timeout=None): 3721 ''' 3722 Create attaches a Node to a PeeringGroup 3723 ''' 3724 deadline = None if timeout is None else time.time() + timeout 3725 req = PeeringGroupNodeCreateRequest() 3726 3727 if peering_group_node is not None: 3728 req.peering_group_node.CopyFrom( 3729 plumbing.convert_peering_group_node_to_plumbing( 3730 peering_group_node)) 3731 tries = 0 3732 plumbing_response = None 3733 while True: 3734 t = None if deadline is None else deadline - time.time() 3735 try: 3736 plumbing_response = self.stub.Create( 3737 req, 3738 metadata=self.parent.get_metadata( 3739 'PeeringGroupNodes.Create', req), 3740 timeout=t) 3741 except Exception as e: 3742 if self.parent.shouldRetry(tries, e, deadline): 3743 tries += 1 3744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3745 continue 3746 raise plumbing.convert_error_to_porcelain(e) from e 3747 break 3748 3749 resp = models.PeeringGroupNodeCreateResponse() 3750 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3751 plumbing_response.meta) 3752 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3753 plumbing_response.peering_group_node) 3754 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3755 plumbing_response.rate_limit) 3756 return resp 3757 3758 def delete(self, id, timeout=None): 3759 ''' 3760 Delete detaches a Node to a PeeringGroup. 3761 ''' 3762 deadline = None if timeout is None else time.time() + timeout 3763 req = PeeringGroupNodeDeleteRequest() 3764 3765 req.id = (id) 3766 tries = 0 3767 plumbing_response = None 3768 while True: 3769 t = None if deadline is None else deadline - time.time() 3770 try: 3771 plumbing_response = self.stub.Delete( 3772 req, 3773 metadata=self.parent.get_metadata( 3774 'PeeringGroupNodes.Delete', req), 3775 timeout=t) 3776 except Exception as e: 3777 if self.parent.shouldRetry(tries, e, deadline): 3778 tries += 1 3779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 break 3783 3784 resp = models.PeeringGroupNodeDeleteResponse() 3785 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3786 plumbing_response.meta) 3787 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3788 plumbing_response.rate_limit) 3789 return resp 3790 3791 def get(self, id, timeout=None): 3792 ''' 3793 Get reads the information of one peering group to node attachment. 3794 ''' 3795 deadline = None if timeout is None else time.time() + timeout 3796 req = PeeringGroupNodeGetRequest() 3797 if self.parent.snapshot_datetime is not None: 3798 req.meta.CopyFrom(GetRequestMetadata()) 3799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3800 3801 req.id = (id) 3802 tries = 0 3803 plumbing_response = None 3804 while True: 3805 t = None if deadline is None else deadline - time.time() 3806 try: 3807 plumbing_response = self.stub.Get( 3808 req, 3809 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3810 req), 3811 timeout=t) 3812 except Exception as e: 3813 if self.parent.shouldRetry(tries, e, deadline): 3814 tries += 1 3815 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3816 continue 3817 raise plumbing.convert_error_to_porcelain(e) from e 3818 break 3819 3820 resp = models.PeeringGroupNodeGetResponse() 3821 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3822 plumbing_response.meta) 3823 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3824 plumbing_response.peering_group_node) 3825 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3826 plumbing_response.rate_limit) 3827 return resp 3828 3829 def list(self, filter, *args, timeout=None): 3830 ''' 3831 List gets a list of peering group node attachments. 3832 ''' 3833 deadline = None if timeout is None else time.time() + timeout 3834 req = PeeringGroupNodeListRequest() 3835 req.meta.CopyFrom(ListRequestMetadata()) 3836 if self.parent.page_limit > 0: 3837 req.meta.limit = self.parent.page_limit 3838 if self.parent.snapshot_datetime is not None: 3839 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3840 3841 req.filter = plumbing.quote_filter_args(filter, *args) 3842 3843 def generator(svc, req): 3844 tries = 0 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = svc.stub.List( 3849 req, 3850 metadata=svc.parent.get_metadata( 3851 'PeeringGroupNodes.List', req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep( 3857 self.parent.exponentialBackoff(tries, deadline)) 3858 continue 3859 raise plumbing.convert_error_to_porcelain(e) from e 3860 tries = 0 3861 for plumbing_item in plumbing_response.peering_group_nodes: 3862 yield plumbing.convert_peering_group_node_to_porcelain( 3863 plumbing_item) 3864 if plumbing_response.meta.next_cursor == '': 3865 break 3866 req.meta.cursor = plumbing_response.meta.next_cursor 3867 3868 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)
3720 def create(self, peering_group_node, timeout=None): 3721 ''' 3722 Create attaches a Node to a PeeringGroup 3723 ''' 3724 deadline = None if timeout is None else time.time() + timeout 3725 req = PeeringGroupNodeCreateRequest() 3726 3727 if peering_group_node is not None: 3728 req.peering_group_node.CopyFrom( 3729 plumbing.convert_peering_group_node_to_plumbing( 3730 peering_group_node)) 3731 tries = 0 3732 plumbing_response = None 3733 while True: 3734 t = None if deadline is None else deadline - time.time() 3735 try: 3736 plumbing_response = self.stub.Create( 3737 req, 3738 metadata=self.parent.get_metadata( 3739 'PeeringGroupNodes.Create', req), 3740 timeout=t) 3741 except Exception as e: 3742 if self.parent.shouldRetry(tries, e, deadline): 3743 tries += 1 3744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3745 continue 3746 raise plumbing.convert_error_to_porcelain(e) from e 3747 break 3748 3749 resp = models.PeeringGroupNodeCreateResponse() 3750 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3751 plumbing_response.meta) 3752 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3753 plumbing_response.peering_group_node) 3754 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3755 plumbing_response.rate_limit) 3756 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
3758 def delete(self, id, timeout=None): 3759 ''' 3760 Delete detaches a Node to a PeeringGroup. 3761 ''' 3762 deadline = None if timeout is None else time.time() + timeout 3763 req = PeeringGroupNodeDeleteRequest() 3764 3765 req.id = (id) 3766 tries = 0 3767 plumbing_response = None 3768 while True: 3769 t = None if deadline is None else deadline - time.time() 3770 try: 3771 plumbing_response = self.stub.Delete( 3772 req, 3773 metadata=self.parent.get_metadata( 3774 'PeeringGroupNodes.Delete', req), 3775 timeout=t) 3776 except Exception as e: 3777 if self.parent.shouldRetry(tries, e, deadline): 3778 tries += 1 3779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 break 3783 3784 resp = models.PeeringGroupNodeDeleteResponse() 3785 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3786 plumbing_response.meta) 3787 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3788 plumbing_response.rate_limit) 3789 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
3791 def get(self, id, timeout=None): 3792 ''' 3793 Get reads the information of one peering group to node attachment. 3794 ''' 3795 deadline = None if timeout is None else time.time() + timeout 3796 req = PeeringGroupNodeGetRequest() 3797 if self.parent.snapshot_datetime is not None: 3798 req.meta.CopyFrom(GetRequestMetadata()) 3799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3800 3801 req.id = (id) 3802 tries = 0 3803 plumbing_response = None 3804 while True: 3805 t = None if deadline is None else deadline - time.time() 3806 try: 3807 plumbing_response = self.stub.Get( 3808 req, 3809 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3810 req), 3811 timeout=t) 3812 except Exception as e: 3813 if self.parent.shouldRetry(tries, e, deadline): 3814 tries += 1 3815 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3816 continue 3817 raise plumbing.convert_error_to_porcelain(e) from e 3818 break 3819 3820 resp = models.PeeringGroupNodeGetResponse() 3821 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3822 plumbing_response.meta) 3823 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3824 plumbing_response.peering_group_node) 3825 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3826 plumbing_response.rate_limit) 3827 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
3829 def list(self, filter, *args, timeout=None): 3830 ''' 3831 List gets a list of peering group node attachments. 3832 ''' 3833 deadline = None if timeout is None else time.time() + timeout 3834 req = PeeringGroupNodeListRequest() 3835 req.meta.CopyFrom(ListRequestMetadata()) 3836 if self.parent.page_limit > 0: 3837 req.meta.limit = self.parent.page_limit 3838 if self.parent.snapshot_datetime is not None: 3839 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3840 3841 req.filter = plumbing.quote_filter_args(filter, *args) 3842 3843 def generator(svc, req): 3844 tries = 0 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = svc.stub.List( 3849 req, 3850 metadata=svc.parent.get_metadata( 3851 'PeeringGroupNodes.List', req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep( 3857 self.parent.exponentialBackoff(tries, deadline)) 3858 continue 3859 raise plumbing.convert_error_to_porcelain(e) from e 3860 tries = 0 3861 for plumbing_item in plumbing_response.peering_group_nodes: 3862 yield plumbing.convert_peering_group_node_to_porcelain( 3863 plumbing_item) 3864 if plumbing_response.meta.next_cursor == '': 3865 break 3866 req.meta.cursor = plumbing_response.meta.next_cursor 3867 3868 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
3871class PeeringGroupPeers: 3872 ''' 3873 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3874 See `strongdm.models.PeeringGroupPeer`. 3875 ''' 3876 def __init__(self, channel, client): 3877 self.parent = client 3878 self.stub = PeeringGroupPeersStub(channel) 3879 3880 def create(self, peering_group_peer, timeout=None): 3881 ''' 3882 Create links two peering groups. 3883 ''' 3884 deadline = None if timeout is None else time.time() + timeout 3885 req = PeeringGroupPeerCreateRequest() 3886 3887 if peering_group_peer is not None: 3888 req.peering_group_peer.CopyFrom( 3889 plumbing.convert_peering_group_peer_to_plumbing( 3890 peering_group_peer)) 3891 tries = 0 3892 plumbing_response = None 3893 while True: 3894 t = None if deadline is None else deadline - time.time() 3895 try: 3896 plumbing_response = self.stub.Create( 3897 req, 3898 metadata=self.parent.get_metadata( 3899 'PeeringGroupPeers.Create', req), 3900 timeout=t) 3901 except Exception as e: 3902 if self.parent.shouldRetry(tries, e, deadline): 3903 tries += 1 3904 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3905 continue 3906 raise plumbing.convert_error_to_porcelain(e) from e 3907 break 3908 3909 resp = models.PeeringGroupPeerCreateResponse() 3910 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3911 plumbing_response.meta) 3912 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3913 plumbing_response.peering_group_peer) 3914 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3915 plumbing_response.rate_limit) 3916 return resp 3917 3918 def delete(self, id, timeout=None): 3919 ''' 3920 Delete unlinks two peering groups. 3921 ''' 3922 deadline = None if timeout is None else time.time() + timeout 3923 req = PeeringGroupPeerDeleteRequest() 3924 3925 req.id = (id) 3926 tries = 0 3927 plumbing_response = None 3928 while True: 3929 t = None if deadline is None else deadline - time.time() 3930 try: 3931 plumbing_response = self.stub.Delete( 3932 req, 3933 metadata=self.parent.get_metadata( 3934 'PeeringGroupPeers.Delete', req), 3935 timeout=t) 3936 except Exception as e: 3937 if self.parent.shouldRetry(tries, e, deadline): 3938 tries += 1 3939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3940 continue 3941 raise plumbing.convert_error_to_porcelain(e) from e 3942 break 3943 3944 resp = models.PeeringGroupPeerDeleteResponse() 3945 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3946 plumbing_response.meta) 3947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3948 plumbing_response.rate_limit) 3949 return resp 3950 3951 def get(self, id, timeout=None): 3952 ''' 3953 Get reads the information of one peering group link. 3954 ''' 3955 deadline = None if timeout is None else time.time() + timeout 3956 req = PeeringGroupPeerGetRequest() 3957 if self.parent.snapshot_datetime is not None: 3958 req.meta.CopyFrom(GetRequestMetadata()) 3959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3960 3961 req.id = (id) 3962 tries = 0 3963 plumbing_response = None 3964 while True: 3965 t = None if deadline is None else deadline - time.time() 3966 try: 3967 plumbing_response = self.stub.Get( 3968 req, 3969 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3970 req), 3971 timeout=t) 3972 except Exception as e: 3973 if self.parent.shouldRetry(tries, e, deadline): 3974 tries += 1 3975 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3976 continue 3977 raise plumbing.convert_error_to_porcelain(e) from e 3978 break 3979 3980 resp = models.PeeringGroupPeerGetResponse() 3981 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3982 plumbing_response.meta) 3983 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3984 plumbing_response.peering_group_peer) 3985 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3986 plumbing_response.rate_limit) 3987 return resp 3988 3989 def list(self, filter, *args, timeout=None): 3990 ''' 3991 List gets a list of peering group links. 3992 ''' 3993 deadline = None if timeout is None else time.time() + timeout 3994 req = PeeringGroupPeerListRequest() 3995 req.meta.CopyFrom(ListRequestMetadata()) 3996 if self.parent.page_limit > 0: 3997 req.meta.limit = self.parent.page_limit 3998 if self.parent.snapshot_datetime is not None: 3999 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4000 4001 req.filter = plumbing.quote_filter_args(filter, *args) 4002 4003 def generator(svc, req): 4004 tries = 0 4005 while True: 4006 t = None if deadline is None else deadline - time.time() 4007 try: 4008 plumbing_response = svc.stub.List( 4009 req, 4010 metadata=svc.parent.get_metadata( 4011 'PeeringGroupPeers.List', req), 4012 timeout=t) 4013 except Exception as e: 4014 if self.parent.shouldRetry(tries, e, deadline): 4015 tries += 1 4016 time.sleep( 4017 self.parent.exponentialBackoff(tries, deadline)) 4018 continue 4019 raise plumbing.convert_error_to_porcelain(e) from e 4020 tries = 0 4021 for plumbing_item in plumbing_response.peering_group_peers: 4022 yield plumbing.convert_peering_group_peer_to_porcelain( 4023 plumbing_item) 4024 if plumbing_response.meta.next_cursor == '': 4025 break 4026 req.meta.cursor = plumbing_response.meta.next_cursor 4027 4028 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)
3880 def create(self, peering_group_peer, timeout=None): 3881 ''' 3882 Create links two peering groups. 3883 ''' 3884 deadline = None if timeout is None else time.time() + timeout 3885 req = PeeringGroupPeerCreateRequest() 3886 3887 if peering_group_peer is not None: 3888 req.peering_group_peer.CopyFrom( 3889 plumbing.convert_peering_group_peer_to_plumbing( 3890 peering_group_peer)) 3891 tries = 0 3892 plumbing_response = None 3893 while True: 3894 t = None if deadline is None else deadline - time.time() 3895 try: 3896 plumbing_response = self.stub.Create( 3897 req, 3898 metadata=self.parent.get_metadata( 3899 'PeeringGroupPeers.Create', req), 3900 timeout=t) 3901 except Exception as e: 3902 if self.parent.shouldRetry(tries, e, deadline): 3903 tries += 1 3904 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3905 continue 3906 raise plumbing.convert_error_to_porcelain(e) from e 3907 break 3908 3909 resp = models.PeeringGroupPeerCreateResponse() 3910 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3911 plumbing_response.meta) 3912 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3913 plumbing_response.peering_group_peer) 3914 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3915 plumbing_response.rate_limit) 3916 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
3918 def delete(self, id, timeout=None): 3919 ''' 3920 Delete unlinks two peering groups. 3921 ''' 3922 deadline = None if timeout is None else time.time() + timeout 3923 req = PeeringGroupPeerDeleteRequest() 3924 3925 req.id = (id) 3926 tries = 0 3927 plumbing_response = None 3928 while True: 3929 t = None if deadline is None else deadline - time.time() 3930 try: 3931 plumbing_response = self.stub.Delete( 3932 req, 3933 metadata=self.parent.get_metadata( 3934 'PeeringGroupPeers.Delete', req), 3935 timeout=t) 3936 except Exception as e: 3937 if self.parent.shouldRetry(tries, e, deadline): 3938 tries += 1 3939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3940 continue 3941 raise plumbing.convert_error_to_porcelain(e) from e 3942 break 3943 3944 resp = models.PeeringGroupPeerDeleteResponse() 3945 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3946 plumbing_response.meta) 3947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3948 plumbing_response.rate_limit) 3949 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
3951 def get(self, id, timeout=None): 3952 ''' 3953 Get reads the information of one peering group link. 3954 ''' 3955 deadline = None if timeout is None else time.time() + timeout 3956 req = PeeringGroupPeerGetRequest() 3957 if self.parent.snapshot_datetime is not None: 3958 req.meta.CopyFrom(GetRequestMetadata()) 3959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3960 3961 req.id = (id) 3962 tries = 0 3963 plumbing_response = None 3964 while True: 3965 t = None if deadline is None else deadline - time.time() 3966 try: 3967 plumbing_response = self.stub.Get( 3968 req, 3969 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3970 req), 3971 timeout=t) 3972 except Exception as e: 3973 if self.parent.shouldRetry(tries, e, deadline): 3974 tries += 1 3975 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3976 continue 3977 raise plumbing.convert_error_to_porcelain(e) from e 3978 break 3979 3980 resp = models.PeeringGroupPeerGetResponse() 3981 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3982 plumbing_response.meta) 3983 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3984 plumbing_response.peering_group_peer) 3985 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3986 plumbing_response.rate_limit) 3987 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
3989 def list(self, filter, *args, timeout=None): 3990 ''' 3991 List gets a list of peering group links. 3992 ''' 3993 deadline = None if timeout is None else time.time() + timeout 3994 req = PeeringGroupPeerListRequest() 3995 req.meta.CopyFrom(ListRequestMetadata()) 3996 if self.parent.page_limit > 0: 3997 req.meta.limit = self.parent.page_limit 3998 if self.parent.snapshot_datetime is not None: 3999 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4000 4001 req.filter = plumbing.quote_filter_args(filter, *args) 4002 4003 def generator(svc, req): 4004 tries = 0 4005 while True: 4006 t = None if deadline is None else deadline - time.time() 4007 try: 4008 plumbing_response = svc.stub.List( 4009 req, 4010 metadata=svc.parent.get_metadata( 4011 'PeeringGroupPeers.List', req), 4012 timeout=t) 4013 except Exception as e: 4014 if self.parent.shouldRetry(tries, e, deadline): 4015 tries += 1 4016 time.sleep( 4017 self.parent.exponentialBackoff(tries, deadline)) 4018 continue 4019 raise plumbing.convert_error_to_porcelain(e) from e 4020 tries = 0 4021 for plumbing_item in plumbing_response.peering_group_peers: 4022 yield plumbing.convert_peering_group_peer_to_porcelain( 4023 plumbing_item) 4024 if plumbing_response.meta.next_cursor == '': 4025 break 4026 req.meta.cursor = plumbing_response.meta.next_cursor 4027 4028 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
4031class PeeringGroupResources: 4032 ''' 4033 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4034 See `strongdm.models.PeeringGroupResource`. 4035 ''' 4036 def __init__(self, channel, client): 4037 self.parent = client 4038 self.stub = PeeringGroupResourcesStub(channel) 4039 4040 def create(self, peering_group_resource, timeout=None): 4041 ''' 4042 Create attaches a Resource to a PeeringGroup 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = PeeringGroupResourceCreateRequest() 4046 4047 if peering_group_resource is not None: 4048 req.peering_group_resource.CopyFrom( 4049 plumbing.convert_peering_group_resource_to_plumbing( 4050 peering_group_resource)) 4051 tries = 0 4052 plumbing_response = None 4053 while True: 4054 t = None if deadline is None else deadline - time.time() 4055 try: 4056 plumbing_response = self.stub.Create( 4057 req, 4058 metadata=self.parent.get_metadata( 4059 'PeeringGroupResources.Create', req), 4060 timeout=t) 4061 except Exception as e: 4062 if self.parent.shouldRetry(tries, e, deadline): 4063 tries += 1 4064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4065 continue 4066 raise plumbing.convert_error_to_porcelain(e) from e 4067 break 4068 4069 resp = models.PeeringGroupResourceCreateResponse() 4070 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4073 plumbing_response.peering_group_resource) 4074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4075 plumbing_response.rate_limit) 4076 return resp 4077 4078 def delete(self, id, timeout=None): 4079 ''' 4080 Delete detaches a Resource to a PeeringGroup 4081 ''' 4082 deadline = None if timeout is None else time.time() + timeout 4083 req = PeeringGroupResourceDeleteRequest() 4084 4085 req.id = (id) 4086 tries = 0 4087 plumbing_response = None 4088 while True: 4089 t = None if deadline is None else deadline - time.time() 4090 try: 4091 plumbing_response = self.stub.Delete( 4092 req, 4093 metadata=self.parent.get_metadata( 4094 'PeeringGroupResources.Delete', req), 4095 timeout=t) 4096 except Exception as e: 4097 if self.parent.shouldRetry(tries, e, deadline): 4098 tries += 1 4099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4100 continue 4101 raise plumbing.convert_error_to_porcelain(e) from e 4102 break 4103 4104 resp = models.PeeringGroupResourceDeleteResponse() 4105 resp.meta = plumbing.convert_delete_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 return resp 4110 4111 def get(self, id, timeout=None): 4112 ''' 4113 Get reads the information of one peering group to resource attachment. 4114 ''' 4115 deadline = None if timeout is None else time.time() + timeout 4116 req = PeeringGroupResourceGetRequest() 4117 if self.parent.snapshot_datetime is not None: 4118 req.meta.CopyFrom(GetRequestMetadata()) 4119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4120 4121 req.id = (id) 4122 tries = 0 4123 plumbing_response = None 4124 while True: 4125 t = None if deadline is None else deadline - time.time() 4126 try: 4127 plumbing_response = self.stub.Get( 4128 req, 4129 metadata=self.parent.get_metadata( 4130 'PeeringGroupResources.Get', req), 4131 timeout=t) 4132 except Exception as e: 4133 if self.parent.shouldRetry(tries, e, deadline): 4134 tries += 1 4135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4136 continue 4137 raise plumbing.convert_error_to_porcelain(e) from e 4138 break 4139 4140 resp = models.PeeringGroupResourceGetResponse() 4141 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4142 plumbing_response.meta) 4143 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4144 plumbing_response.peering_group_resource) 4145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4146 plumbing_response.rate_limit) 4147 return resp 4148 4149 def list(self, filter, *args, timeout=None): 4150 ''' 4151 List gets a list of peering group resource attachments. 4152 ''' 4153 deadline = None if timeout is None else time.time() + timeout 4154 req = PeeringGroupResourceListRequest() 4155 req.meta.CopyFrom(ListRequestMetadata()) 4156 if self.parent.page_limit > 0: 4157 req.meta.limit = self.parent.page_limit 4158 if self.parent.snapshot_datetime is not None: 4159 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4160 4161 req.filter = plumbing.quote_filter_args(filter, *args) 4162 4163 def generator(svc, req): 4164 tries = 0 4165 while True: 4166 t = None if deadline is None else deadline - time.time() 4167 try: 4168 plumbing_response = svc.stub.List( 4169 req, 4170 metadata=svc.parent.get_metadata( 4171 'PeeringGroupResources.List', req), 4172 timeout=t) 4173 except Exception as e: 4174 if self.parent.shouldRetry(tries, e, deadline): 4175 tries += 1 4176 time.sleep( 4177 self.parent.exponentialBackoff(tries, deadline)) 4178 continue 4179 raise plumbing.convert_error_to_porcelain(e) from e 4180 tries = 0 4181 for plumbing_item in plumbing_response.peering_group_resources: 4182 yield plumbing.convert_peering_group_resource_to_porcelain( 4183 plumbing_item) 4184 if plumbing_response.meta.next_cursor == '': 4185 break 4186 req.meta.cursor = plumbing_response.meta.next_cursor 4187 4188 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)
4040 def create(self, peering_group_resource, timeout=None): 4041 ''' 4042 Create attaches a Resource to a PeeringGroup 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = PeeringGroupResourceCreateRequest() 4046 4047 if peering_group_resource is not None: 4048 req.peering_group_resource.CopyFrom( 4049 plumbing.convert_peering_group_resource_to_plumbing( 4050 peering_group_resource)) 4051 tries = 0 4052 plumbing_response = None 4053 while True: 4054 t = None if deadline is None else deadline - time.time() 4055 try: 4056 plumbing_response = self.stub.Create( 4057 req, 4058 metadata=self.parent.get_metadata( 4059 'PeeringGroupResources.Create', req), 4060 timeout=t) 4061 except Exception as e: 4062 if self.parent.shouldRetry(tries, e, deadline): 4063 tries += 1 4064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4065 continue 4066 raise plumbing.convert_error_to_porcelain(e) from e 4067 break 4068 4069 resp = models.PeeringGroupResourceCreateResponse() 4070 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4073 plumbing_response.peering_group_resource) 4074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4075 plumbing_response.rate_limit) 4076 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
4078 def delete(self, id, timeout=None): 4079 ''' 4080 Delete detaches a Resource to a PeeringGroup 4081 ''' 4082 deadline = None if timeout is None else time.time() + timeout 4083 req = PeeringGroupResourceDeleteRequest() 4084 4085 req.id = (id) 4086 tries = 0 4087 plumbing_response = None 4088 while True: 4089 t = None if deadline is None else deadline - time.time() 4090 try: 4091 plumbing_response = self.stub.Delete( 4092 req, 4093 metadata=self.parent.get_metadata( 4094 'PeeringGroupResources.Delete', req), 4095 timeout=t) 4096 except Exception as e: 4097 if self.parent.shouldRetry(tries, e, deadline): 4098 tries += 1 4099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4100 continue 4101 raise plumbing.convert_error_to_porcelain(e) from e 4102 break 4103 4104 resp = models.PeeringGroupResourceDeleteResponse() 4105 resp.meta = plumbing.convert_delete_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 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
4111 def get(self, id, timeout=None): 4112 ''' 4113 Get reads the information of one peering group to resource attachment. 4114 ''' 4115 deadline = None if timeout is None else time.time() + timeout 4116 req = PeeringGroupResourceGetRequest() 4117 if self.parent.snapshot_datetime is not None: 4118 req.meta.CopyFrom(GetRequestMetadata()) 4119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4120 4121 req.id = (id) 4122 tries = 0 4123 plumbing_response = None 4124 while True: 4125 t = None if deadline is None else deadline - time.time() 4126 try: 4127 plumbing_response = self.stub.Get( 4128 req, 4129 metadata=self.parent.get_metadata( 4130 'PeeringGroupResources.Get', req), 4131 timeout=t) 4132 except Exception as e: 4133 if self.parent.shouldRetry(tries, e, deadline): 4134 tries += 1 4135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4136 continue 4137 raise plumbing.convert_error_to_porcelain(e) from e 4138 break 4139 4140 resp = models.PeeringGroupResourceGetResponse() 4141 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4142 plumbing_response.meta) 4143 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4144 plumbing_response.peering_group_resource) 4145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4146 plumbing_response.rate_limit) 4147 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
4149 def list(self, filter, *args, timeout=None): 4150 ''' 4151 List gets a list of peering group resource attachments. 4152 ''' 4153 deadline = None if timeout is None else time.time() + timeout 4154 req = PeeringGroupResourceListRequest() 4155 req.meta.CopyFrom(ListRequestMetadata()) 4156 if self.parent.page_limit > 0: 4157 req.meta.limit = self.parent.page_limit 4158 if self.parent.snapshot_datetime is not None: 4159 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4160 4161 req.filter = plumbing.quote_filter_args(filter, *args) 4162 4163 def generator(svc, req): 4164 tries = 0 4165 while True: 4166 t = None if deadline is None else deadline - time.time() 4167 try: 4168 plumbing_response = svc.stub.List( 4169 req, 4170 metadata=svc.parent.get_metadata( 4171 'PeeringGroupResources.List', req), 4172 timeout=t) 4173 except Exception as e: 4174 if self.parent.shouldRetry(tries, e, deadline): 4175 tries += 1 4176 time.sleep( 4177 self.parent.exponentialBackoff(tries, deadline)) 4178 continue 4179 raise plumbing.convert_error_to_porcelain(e) from e 4180 tries = 0 4181 for plumbing_item in plumbing_response.peering_group_resources: 4182 yield plumbing.convert_peering_group_resource_to_porcelain( 4183 plumbing_item) 4184 if plumbing_response.meta.next_cursor == '': 4185 break 4186 req.meta.cursor = plumbing_response.meta.next_cursor 4187 4188 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
4191class PeeringGroups: 4192 ''' 4193 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4194 See `strongdm.models.PeeringGroup`. 4195 ''' 4196 def __init__(self, channel, client): 4197 self.parent = client 4198 self.stub = PeeringGroupsStub(channel) 4199 4200 def create(self, peering_group, timeout=None): 4201 ''' 4202 Create registers a new PeeringGroup. 4203 ''' 4204 deadline = None if timeout is None else time.time() + timeout 4205 req = PeeringGroupCreateRequest() 4206 4207 if peering_group is not None: 4208 req.peering_group.CopyFrom( 4209 plumbing.convert_peering_group_to_plumbing(peering_group)) 4210 tries = 0 4211 plumbing_response = None 4212 while True: 4213 t = None if deadline is None else deadline - time.time() 4214 try: 4215 plumbing_response = self.stub.Create( 4216 req, 4217 metadata=self.parent.get_metadata('PeeringGroups.Create', 4218 req), 4219 timeout=t) 4220 except Exception as e: 4221 if self.parent.shouldRetry(tries, e, deadline): 4222 tries += 1 4223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4224 continue 4225 raise plumbing.convert_error_to_porcelain(e) from e 4226 break 4227 4228 resp = models.PeeringGroupCreateResponse() 4229 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4230 plumbing_response.meta) 4231 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4232 plumbing_response.peering_group) 4233 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4234 plumbing_response.rate_limit) 4235 return resp 4236 4237 def delete(self, id, timeout=None): 4238 ''' 4239 Delete removes a PeeringGroup by ID. 4240 ''' 4241 deadline = None if timeout is None else time.time() + timeout 4242 req = PeeringGroupDeleteRequest() 4243 4244 req.id = (id) 4245 tries = 0 4246 plumbing_response = None 4247 while True: 4248 t = None if deadline is None else deadline - time.time() 4249 try: 4250 plumbing_response = self.stub.Delete( 4251 req, 4252 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4253 req), 4254 timeout=t) 4255 except Exception as e: 4256 if self.parent.shouldRetry(tries, e, deadline): 4257 tries += 1 4258 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4259 continue 4260 raise plumbing.convert_error_to_porcelain(e) from e 4261 break 4262 4263 resp = models.PeeringGroupDeleteResponse() 4264 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4265 plumbing_response.meta) 4266 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4267 plumbing_response.rate_limit) 4268 return resp 4269 4270 def get(self, id, timeout=None): 4271 ''' 4272 Get reads one PeeringGroup by ID. It will load all its dependencies. 4273 ''' 4274 deadline = None if timeout is None else time.time() + timeout 4275 req = PeeringGroupGetRequest() 4276 if self.parent.snapshot_datetime is not None: 4277 req.meta.CopyFrom(GetRequestMetadata()) 4278 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 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.Get( 4287 req, 4288 metadata=self.parent.get_metadata('PeeringGroups.Get', 4289 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.PeeringGroupGetResponse() 4300 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4301 plumbing_response.meta) 4302 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4303 plumbing_response.peering_group) 4304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4305 plumbing_response.rate_limit) 4306 return resp 4307 4308 def list(self, filter, *args, timeout=None): 4309 ''' 4310 List gets a list of Peering Groups. 4311 ''' 4312 deadline = None if timeout is None else time.time() + timeout 4313 req = PeeringGroupListRequest() 4314 req.meta.CopyFrom(ListRequestMetadata()) 4315 if self.parent.page_limit > 0: 4316 req.meta.limit = self.parent.page_limit 4317 if self.parent.snapshot_datetime is not None: 4318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4319 4320 req.filter = plumbing.quote_filter_args(filter, *args) 4321 4322 def generator(svc, req): 4323 tries = 0 4324 while True: 4325 t = None if deadline is None else deadline - time.time() 4326 try: 4327 plumbing_response = svc.stub.List( 4328 req, 4329 metadata=svc.parent.get_metadata( 4330 'PeeringGroups.List', req), 4331 timeout=t) 4332 except Exception as e: 4333 if self.parent.shouldRetry(tries, e, deadline): 4334 tries += 1 4335 time.sleep( 4336 self.parent.exponentialBackoff(tries, deadline)) 4337 continue 4338 raise plumbing.convert_error_to_porcelain(e) from e 4339 tries = 0 4340 for plumbing_item in plumbing_response.peering_groups: 4341 yield plumbing.convert_peering_group_to_porcelain( 4342 plumbing_item) 4343 if plumbing_response.meta.next_cursor == '': 4344 break 4345 req.meta.cursor = plumbing_response.meta.next_cursor 4346 4347 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)
4200 def create(self, peering_group, timeout=None): 4201 ''' 4202 Create registers a new PeeringGroup. 4203 ''' 4204 deadline = None if timeout is None else time.time() + timeout 4205 req = PeeringGroupCreateRequest() 4206 4207 if peering_group is not None: 4208 req.peering_group.CopyFrom( 4209 plumbing.convert_peering_group_to_plumbing(peering_group)) 4210 tries = 0 4211 plumbing_response = None 4212 while True: 4213 t = None if deadline is None else deadline - time.time() 4214 try: 4215 plumbing_response = self.stub.Create( 4216 req, 4217 metadata=self.parent.get_metadata('PeeringGroups.Create', 4218 req), 4219 timeout=t) 4220 except Exception as e: 4221 if self.parent.shouldRetry(tries, e, deadline): 4222 tries += 1 4223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4224 continue 4225 raise plumbing.convert_error_to_porcelain(e) from e 4226 break 4227 4228 resp = models.PeeringGroupCreateResponse() 4229 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4230 plumbing_response.meta) 4231 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4232 plumbing_response.peering_group) 4233 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4234 plumbing_response.rate_limit) 4235 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
4237 def delete(self, id, timeout=None): 4238 ''' 4239 Delete removes a PeeringGroup by ID. 4240 ''' 4241 deadline = None if timeout is None else time.time() + timeout 4242 req = PeeringGroupDeleteRequest() 4243 4244 req.id = (id) 4245 tries = 0 4246 plumbing_response = None 4247 while True: 4248 t = None if deadline is None else deadline - time.time() 4249 try: 4250 plumbing_response = self.stub.Delete( 4251 req, 4252 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4253 req), 4254 timeout=t) 4255 except Exception as e: 4256 if self.parent.shouldRetry(tries, e, deadline): 4257 tries += 1 4258 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4259 continue 4260 raise plumbing.convert_error_to_porcelain(e) from e 4261 break 4262 4263 resp = models.PeeringGroupDeleteResponse() 4264 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4265 plumbing_response.meta) 4266 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4267 plumbing_response.rate_limit) 4268 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
4270 def get(self, id, timeout=None): 4271 ''' 4272 Get reads one PeeringGroup by ID. It will load all its dependencies. 4273 ''' 4274 deadline = None if timeout is None else time.time() + timeout 4275 req = PeeringGroupGetRequest() 4276 if self.parent.snapshot_datetime is not None: 4277 req.meta.CopyFrom(GetRequestMetadata()) 4278 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 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.Get( 4287 req, 4288 metadata=self.parent.get_metadata('PeeringGroups.Get', 4289 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.PeeringGroupGetResponse() 4300 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4301 plumbing_response.meta) 4302 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4303 plumbing_response.peering_group) 4304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4305 plumbing_response.rate_limit) 4306 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
4308 def list(self, filter, *args, timeout=None): 4309 ''' 4310 List gets a list of Peering Groups. 4311 ''' 4312 deadline = None if timeout is None else time.time() + timeout 4313 req = PeeringGroupListRequest() 4314 req.meta.CopyFrom(ListRequestMetadata()) 4315 if self.parent.page_limit > 0: 4316 req.meta.limit = self.parent.page_limit 4317 if self.parent.snapshot_datetime is not None: 4318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4319 4320 req.filter = plumbing.quote_filter_args(filter, *args) 4321 4322 def generator(svc, req): 4323 tries = 0 4324 while True: 4325 t = None if deadline is None else deadline - time.time() 4326 try: 4327 plumbing_response = svc.stub.List( 4328 req, 4329 metadata=svc.parent.get_metadata( 4330 'PeeringGroups.List', req), 4331 timeout=t) 4332 except Exception as e: 4333 if self.parent.shouldRetry(tries, e, deadline): 4334 tries += 1 4335 time.sleep( 4336 self.parent.exponentialBackoff(tries, deadline)) 4337 continue 4338 raise plumbing.convert_error_to_porcelain(e) from e 4339 tries = 0 4340 for plumbing_item in plumbing_response.peering_groups: 4341 yield plumbing.convert_peering_group_to_porcelain( 4342 plumbing_item) 4343 if plumbing_response.meta.next_cursor == '': 4344 break 4345 req.meta.cursor = plumbing_response.meta.next_cursor 4346 4347 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
4350class Policies: 4351 ''' 4352 Policies are the collection of one or more statements that enforce fine-grained access 4353 control for the users of an organization. 4354 See `strongdm.models.Policy`. 4355 ''' 4356 def __init__(self, channel, client): 4357 self.parent = client 4358 self.stub = PoliciesStub(channel) 4359 4360 def create(self, policy, timeout=None): 4361 ''' 4362 Create creates a new Policy. 4363 ''' 4364 deadline = None if timeout is None else time.time() + timeout 4365 req = PolicyCreateRequest() 4366 4367 if policy is not None: 4368 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4369 tries = 0 4370 plumbing_response = None 4371 while True: 4372 t = None if deadline is None else deadline - time.time() 4373 try: 4374 plumbing_response = self.stub.Create( 4375 req, 4376 metadata=self.parent.get_metadata('Policies.Create', req), 4377 timeout=t) 4378 except Exception as e: 4379 if self.parent.shouldRetry(tries, e, deadline): 4380 tries += 1 4381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4382 continue 4383 raise plumbing.convert_error_to_porcelain(e) from e 4384 break 4385 4386 resp = models.PolicyCreateResponse() 4387 resp.policy = plumbing.convert_policy_to_porcelain( 4388 plumbing_response.policy) 4389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4390 plumbing_response.rate_limit) 4391 return resp 4392 4393 def delete(self, id, timeout=None): 4394 ''' 4395 Delete removes a Policy by ID. 4396 ''' 4397 deadline = None if timeout is None else time.time() + timeout 4398 req = PolicyDeleteRequest() 4399 4400 req.id = (id) 4401 tries = 0 4402 plumbing_response = None 4403 while True: 4404 t = None if deadline is None else deadline - time.time() 4405 try: 4406 plumbing_response = self.stub.Delete( 4407 req, 4408 metadata=self.parent.get_metadata('Policies.Delete', req), 4409 timeout=t) 4410 except Exception as e: 4411 if self.parent.shouldRetry(tries, e, deadline): 4412 tries += 1 4413 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4414 continue 4415 raise plumbing.convert_error_to_porcelain(e) from e 4416 break 4417 4418 resp = models.PolicyDeleteResponse() 4419 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4420 plumbing_response.rate_limit) 4421 return resp 4422 4423 def update(self, policy, timeout=None): 4424 ''' 4425 Update replaces all the fields of a Policy by ID. 4426 ''' 4427 deadline = None if timeout is None else time.time() + timeout 4428 req = PolicyUpdateRequest() 4429 4430 if policy is not None: 4431 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4432 tries = 0 4433 plumbing_response = None 4434 while True: 4435 t = None if deadline is None else deadline - time.time() 4436 try: 4437 plumbing_response = self.stub.Update( 4438 req, 4439 metadata=self.parent.get_metadata('Policies.Update', req), 4440 timeout=t) 4441 except Exception as e: 4442 if self.parent.shouldRetry(tries, e, deadline): 4443 tries += 1 4444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4445 continue 4446 raise plumbing.convert_error_to_porcelain(e) from e 4447 break 4448 4449 resp = models.PolicyUpdateResponse() 4450 resp.policy = plumbing.convert_policy_to_porcelain( 4451 plumbing_response.policy) 4452 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4453 plumbing_response.rate_limit) 4454 return resp 4455 4456 def get(self, id, timeout=None): 4457 ''' 4458 Get reads one Policy by ID. 4459 ''' 4460 deadline = None if timeout is None else time.time() + timeout 4461 req = PolicyGetRequest() 4462 if self.parent.snapshot_datetime is not None: 4463 req.meta.CopyFrom(GetRequestMetadata()) 4464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4465 4466 req.id = (id) 4467 tries = 0 4468 plumbing_response = None 4469 while True: 4470 t = None if deadline is None else deadline - time.time() 4471 try: 4472 plumbing_response = self.stub.Get( 4473 req, 4474 metadata=self.parent.get_metadata('Policies.Get', req), 4475 timeout=t) 4476 except Exception as e: 4477 if self.parent.shouldRetry(tries, e, deadline): 4478 tries += 1 4479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4480 continue 4481 raise plumbing.convert_error_to_porcelain(e) from e 4482 break 4483 4484 resp = models.PolicyGetResponse() 4485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4486 plumbing_response.meta) 4487 resp.policy = plumbing.convert_policy_to_porcelain( 4488 plumbing_response.policy) 4489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4490 plumbing_response.rate_limit) 4491 return resp 4492 4493 def list(self, filter, *args, timeout=None): 4494 ''' 4495 List gets a list of Policy matching a given set of criteria 4496 ''' 4497 deadline = None if timeout is None else time.time() + timeout 4498 req = PolicyListRequest() 4499 req.meta.CopyFrom(ListRequestMetadata()) 4500 if self.parent.page_limit > 0: 4501 req.meta.limit = self.parent.page_limit 4502 if self.parent.snapshot_datetime is not None: 4503 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4504 4505 req.filter = plumbing.quote_filter_args(filter, *args) 4506 4507 def generator(svc, req): 4508 tries = 0 4509 while True: 4510 t = None if deadline is None else deadline - time.time() 4511 try: 4512 plumbing_response = svc.stub.List( 4513 req, 4514 metadata=svc.parent.get_metadata('Policies.List', req), 4515 timeout=t) 4516 except Exception as e: 4517 if self.parent.shouldRetry(tries, e, deadline): 4518 tries += 1 4519 time.sleep( 4520 self.parent.exponentialBackoff(tries, deadline)) 4521 continue 4522 raise plumbing.convert_error_to_porcelain(e) from e 4523 tries = 0 4524 for plumbing_item in plumbing_response.policies: 4525 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4526 if plumbing_response.meta.next_cursor == '': 4527 break 4528 req.meta.cursor = plumbing_response.meta.next_cursor 4529 4530 return generator(self, req)
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)
4360 def create(self, policy, timeout=None): 4361 ''' 4362 Create creates a new Policy. 4363 ''' 4364 deadline = None if timeout is None else time.time() + timeout 4365 req = PolicyCreateRequest() 4366 4367 if policy is not None: 4368 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4369 tries = 0 4370 plumbing_response = None 4371 while True: 4372 t = None if deadline is None else deadline - time.time() 4373 try: 4374 plumbing_response = self.stub.Create( 4375 req, 4376 metadata=self.parent.get_metadata('Policies.Create', req), 4377 timeout=t) 4378 except Exception as e: 4379 if self.parent.shouldRetry(tries, e, deadline): 4380 tries += 1 4381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4382 continue 4383 raise plumbing.convert_error_to_porcelain(e) from e 4384 break 4385 4386 resp = models.PolicyCreateResponse() 4387 resp.policy = plumbing.convert_policy_to_porcelain( 4388 plumbing_response.policy) 4389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4390 plumbing_response.rate_limit) 4391 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
4393 def delete(self, id, timeout=None): 4394 ''' 4395 Delete removes a Policy by ID. 4396 ''' 4397 deadline = None if timeout is None else time.time() + timeout 4398 req = PolicyDeleteRequest() 4399 4400 req.id = (id) 4401 tries = 0 4402 plumbing_response = None 4403 while True: 4404 t = None if deadline is None else deadline - time.time() 4405 try: 4406 plumbing_response = self.stub.Delete( 4407 req, 4408 metadata=self.parent.get_metadata('Policies.Delete', req), 4409 timeout=t) 4410 except Exception as e: 4411 if self.parent.shouldRetry(tries, e, deadline): 4412 tries += 1 4413 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4414 continue 4415 raise plumbing.convert_error_to_porcelain(e) from e 4416 break 4417 4418 resp = models.PolicyDeleteResponse() 4419 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4420 plumbing_response.rate_limit) 4421 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
4423 def update(self, policy, timeout=None): 4424 ''' 4425 Update replaces all the fields of a Policy by ID. 4426 ''' 4427 deadline = None if timeout is None else time.time() + timeout 4428 req = PolicyUpdateRequest() 4429 4430 if policy is not None: 4431 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4432 tries = 0 4433 plumbing_response = None 4434 while True: 4435 t = None if deadline is None else deadline - time.time() 4436 try: 4437 plumbing_response = self.stub.Update( 4438 req, 4439 metadata=self.parent.get_metadata('Policies.Update', req), 4440 timeout=t) 4441 except Exception as e: 4442 if self.parent.shouldRetry(tries, e, deadline): 4443 tries += 1 4444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4445 continue 4446 raise plumbing.convert_error_to_porcelain(e) from e 4447 break 4448 4449 resp = models.PolicyUpdateResponse() 4450 resp.policy = plumbing.convert_policy_to_porcelain( 4451 plumbing_response.policy) 4452 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4453 plumbing_response.rate_limit) 4454 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
4456 def get(self, id, timeout=None): 4457 ''' 4458 Get reads one Policy by ID. 4459 ''' 4460 deadline = None if timeout is None else time.time() + timeout 4461 req = PolicyGetRequest() 4462 if self.parent.snapshot_datetime is not None: 4463 req.meta.CopyFrom(GetRequestMetadata()) 4464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4465 4466 req.id = (id) 4467 tries = 0 4468 plumbing_response = None 4469 while True: 4470 t = None if deadline is None else deadline - time.time() 4471 try: 4472 plumbing_response = self.stub.Get( 4473 req, 4474 metadata=self.parent.get_metadata('Policies.Get', req), 4475 timeout=t) 4476 except Exception as e: 4477 if self.parent.shouldRetry(tries, e, deadline): 4478 tries += 1 4479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4480 continue 4481 raise plumbing.convert_error_to_porcelain(e) from e 4482 break 4483 4484 resp = models.PolicyGetResponse() 4485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4486 plumbing_response.meta) 4487 resp.policy = plumbing.convert_policy_to_porcelain( 4488 plumbing_response.policy) 4489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4490 plumbing_response.rate_limit) 4491 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
4493 def list(self, filter, *args, timeout=None): 4494 ''' 4495 List gets a list of Policy matching a given set of criteria 4496 ''' 4497 deadline = None if timeout is None else time.time() + timeout 4498 req = PolicyListRequest() 4499 req.meta.CopyFrom(ListRequestMetadata()) 4500 if self.parent.page_limit > 0: 4501 req.meta.limit = self.parent.page_limit 4502 if self.parent.snapshot_datetime is not None: 4503 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4504 4505 req.filter = plumbing.quote_filter_args(filter, *args) 4506 4507 def generator(svc, req): 4508 tries = 0 4509 while True: 4510 t = None if deadline is None else deadline - time.time() 4511 try: 4512 plumbing_response = svc.stub.List( 4513 req, 4514 metadata=svc.parent.get_metadata('Policies.List', req), 4515 timeout=t) 4516 except Exception as e: 4517 if self.parent.shouldRetry(tries, e, deadline): 4518 tries += 1 4519 time.sleep( 4520 self.parent.exponentialBackoff(tries, deadline)) 4521 continue 4522 raise plumbing.convert_error_to_porcelain(e) from e 4523 tries = 0 4524 for plumbing_item in plumbing_response.policies: 4525 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4526 if plumbing_response.meta.next_cursor == '': 4527 break 4528 req.meta.cursor = plumbing_response.meta.next_cursor 4529 4530 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
4533class SnapshotPolicies: 4534 ''' 4535 SnapshotPolicies exposes the read only methods of the Policies 4536 service for historical queries. 4537 ''' 4538 def __init__(self, policies): 4539 self.policies = policies 4540 4541 def get(self, id, timeout=None): 4542 ''' 4543 Get reads one Policy by ID. 4544 ''' 4545 return self.policies.get(id, timeout=timeout) 4546 4547 def list(self, filter, *args, timeout=None): 4548 ''' 4549 List gets a list of Policy matching a given set of criteria 4550 ''' 4551 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
4554class PoliciesHistory: 4555 ''' 4556 PoliciesHistory records all changes to the state of a Policy. 4557 See `strongdm.models.PolicyHistory`. 4558 ''' 4559 def __init__(self, channel, client): 4560 self.parent = client 4561 self.stub = PoliciesHistoryStub(channel) 4562 4563 def list(self, filter, *args, timeout=None): 4564 ''' 4565 List gets a list of PolicyHistory records matching a given set of criteria. 4566 ''' 4567 deadline = None if timeout is None else time.time() + timeout 4568 req = PoliciesHistoryListRequest() 4569 req.meta.CopyFrom(ListRequestMetadata()) 4570 if self.parent.page_limit > 0: 4571 req.meta.limit = self.parent.page_limit 4572 if self.parent.snapshot_datetime is not None: 4573 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4574 4575 req.filter = plumbing.quote_filter_args(filter, *args) 4576 4577 def generator(svc, req): 4578 tries = 0 4579 while True: 4580 t = None if deadline is None else deadline - time.time() 4581 try: 4582 plumbing_response = svc.stub.List( 4583 req, 4584 metadata=svc.parent.get_metadata( 4585 'PoliciesHistory.List', req), 4586 timeout=t) 4587 except Exception as e: 4588 if self.parent.shouldRetry(tries, e, deadline): 4589 tries += 1 4590 time.sleep( 4591 self.parent.exponentialBackoff(tries, deadline)) 4592 continue 4593 raise plumbing.convert_error_to_porcelain(e) from e 4594 tries = 0 4595 for plumbing_item in plumbing_response.history: 4596 yield plumbing.convert_policy_history_to_porcelain( 4597 plumbing_item) 4598 if plumbing_response.meta.next_cursor == '': 4599 break 4600 req.meta.cursor = plumbing_response.meta.next_cursor 4601 4602 return generator(self, req)
PoliciesHistory records all changes to the state of a Policy.
See strongdm.models.PolicyHistory.
def
list(self, filter, *args, timeout=None)
4563 def list(self, filter, *args, timeout=None): 4564 ''' 4565 List gets a list of PolicyHistory records matching a given set of criteria. 4566 ''' 4567 deadline = None if timeout is None else time.time() + timeout 4568 req = PoliciesHistoryListRequest() 4569 req.meta.CopyFrom(ListRequestMetadata()) 4570 if self.parent.page_limit > 0: 4571 req.meta.limit = self.parent.page_limit 4572 if self.parent.snapshot_datetime is not None: 4573 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4574 4575 req.filter = plumbing.quote_filter_args(filter, *args) 4576 4577 def generator(svc, req): 4578 tries = 0 4579 while True: 4580 t = None if deadline is None else deadline - time.time() 4581 try: 4582 plumbing_response = svc.stub.List( 4583 req, 4584 metadata=svc.parent.get_metadata( 4585 'PoliciesHistory.List', req), 4586 timeout=t) 4587 except Exception as e: 4588 if self.parent.shouldRetry(tries, e, deadline): 4589 tries += 1 4590 time.sleep( 4591 self.parent.exponentialBackoff(tries, deadline)) 4592 continue 4593 raise plumbing.convert_error_to_porcelain(e) from e 4594 tries = 0 4595 for plumbing_item in plumbing_response.history: 4596 yield plumbing.convert_policy_history_to_porcelain( 4597 plumbing_item) 4598 if plumbing_response.meta.next_cursor == '': 4599 break 4600 req.meta.cursor = plumbing_response.meta.next_cursor 4601 4602 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
4605class ProxyClusterKeys: 4606 ''' 4607 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4608 The proxies within a cluster share the same key. One cluster can have 4609 multiple keys in order to facilitate key rotation. 4610 See `strongdm.models.ProxyClusterKey`. 4611 ''' 4612 def __init__(self, channel, client): 4613 self.parent = client 4614 self.stub = ProxyClusterKeysStub(channel) 4615 4616 def create(self, proxy_cluster_key, timeout=None): 4617 ''' 4618 Create registers a new ProxyClusterKey. 4619 ''' 4620 deadline = None if timeout is None else time.time() + timeout 4621 req = ProxyClusterKeyCreateRequest() 4622 4623 if proxy_cluster_key is not None: 4624 req.proxy_cluster_key.CopyFrom( 4625 plumbing.convert_proxy_cluster_key_to_plumbing( 4626 proxy_cluster_key)) 4627 tries = 0 4628 plumbing_response = None 4629 while True: 4630 t = None if deadline is None else deadline - time.time() 4631 try: 4632 plumbing_response = self.stub.Create( 4633 req, 4634 metadata=self.parent.get_metadata( 4635 'ProxyClusterKeys.Create', req), 4636 timeout=t) 4637 except Exception as e: 4638 if self.parent.shouldRetry(tries, e, deadline): 4639 tries += 1 4640 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4641 continue 4642 raise plumbing.convert_error_to_porcelain(e) from e 4643 break 4644 4645 resp = models.ProxyClusterKeyCreateResponse() 4646 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4647 plumbing_response.meta) 4648 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4649 plumbing_response.proxy_cluster_key) 4650 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4651 plumbing_response.rate_limit) 4652 resp.secret_key = (plumbing_response.secret_key) 4653 return resp 4654 4655 def get(self, id, timeout=None): 4656 ''' 4657 Get reads one ProxyClusterKey by ID. 4658 ''' 4659 deadline = None if timeout is None else time.time() + timeout 4660 req = ProxyClusterKeyGetRequest() 4661 if self.parent.snapshot_datetime is not None: 4662 req.meta.CopyFrom(GetRequestMetadata()) 4663 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4664 4665 req.id = (id) 4666 tries = 0 4667 plumbing_response = None 4668 while True: 4669 t = None if deadline is None else deadline - time.time() 4670 try: 4671 plumbing_response = self.stub.Get( 4672 req, 4673 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4674 req), 4675 timeout=t) 4676 except Exception as e: 4677 if self.parent.shouldRetry(tries, e, deadline): 4678 tries += 1 4679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4680 continue 4681 raise plumbing.convert_error_to_porcelain(e) from e 4682 break 4683 4684 resp = models.ProxyClusterKeyGetResponse() 4685 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4686 plumbing_response.meta) 4687 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4688 plumbing_response.proxy_cluster_key) 4689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4690 plumbing_response.rate_limit) 4691 return resp 4692 4693 def delete(self, id, timeout=None): 4694 ''' 4695 Delete removes a ProxyClusterKey by ID. 4696 ''' 4697 deadline = None if timeout is None else time.time() + timeout 4698 req = ProxyClusterKeyDeleteRequest() 4699 4700 req.id = (id) 4701 tries = 0 4702 plumbing_response = None 4703 while True: 4704 t = None if deadline is None else deadline - time.time() 4705 try: 4706 plumbing_response = self.stub.Delete( 4707 req, 4708 metadata=self.parent.get_metadata( 4709 'ProxyClusterKeys.Delete', req), 4710 timeout=t) 4711 except Exception as e: 4712 if self.parent.shouldRetry(tries, e, deadline): 4713 tries += 1 4714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4715 continue 4716 raise plumbing.convert_error_to_porcelain(e) from e 4717 break 4718 4719 resp = models.ProxyClusterKeyDeleteResponse() 4720 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4721 plumbing_response.meta) 4722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4723 plumbing_response.rate_limit) 4724 return resp 4725 4726 def list(self, filter, *args, timeout=None): 4727 ''' 4728 List gets a list of ProxyClusterKeys matching a given set of criteria. 4729 ''' 4730 deadline = None if timeout is None else time.time() + timeout 4731 req = ProxyClusterKeyListRequest() 4732 req.meta.CopyFrom(ListRequestMetadata()) 4733 if self.parent.page_limit > 0: 4734 req.meta.limit = self.parent.page_limit 4735 if self.parent.snapshot_datetime is not None: 4736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4737 4738 req.filter = plumbing.quote_filter_args(filter, *args) 4739 4740 def generator(svc, req): 4741 tries = 0 4742 while True: 4743 t = None if deadline is None else deadline - time.time() 4744 try: 4745 plumbing_response = svc.stub.List( 4746 req, 4747 metadata=svc.parent.get_metadata( 4748 'ProxyClusterKeys.List', req), 4749 timeout=t) 4750 except Exception as e: 4751 if self.parent.shouldRetry(tries, e, deadline): 4752 tries += 1 4753 time.sleep( 4754 self.parent.exponentialBackoff(tries, deadline)) 4755 continue 4756 raise plumbing.convert_error_to_porcelain(e) from e 4757 tries = 0 4758 for plumbing_item in plumbing_response.proxy_cluster_keys: 4759 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4760 plumbing_item) 4761 if plumbing_response.meta.next_cursor == '': 4762 break 4763 req.meta.cursor = plumbing_response.meta.next_cursor 4764 4765 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)
4616 def create(self, proxy_cluster_key, timeout=None): 4617 ''' 4618 Create registers a new ProxyClusterKey. 4619 ''' 4620 deadline = None if timeout is None else time.time() + timeout 4621 req = ProxyClusterKeyCreateRequest() 4622 4623 if proxy_cluster_key is not None: 4624 req.proxy_cluster_key.CopyFrom( 4625 plumbing.convert_proxy_cluster_key_to_plumbing( 4626 proxy_cluster_key)) 4627 tries = 0 4628 plumbing_response = None 4629 while True: 4630 t = None if deadline is None else deadline - time.time() 4631 try: 4632 plumbing_response = self.stub.Create( 4633 req, 4634 metadata=self.parent.get_metadata( 4635 'ProxyClusterKeys.Create', req), 4636 timeout=t) 4637 except Exception as e: 4638 if self.parent.shouldRetry(tries, e, deadline): 4639 tries += 1 4640 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4641 continue 4642 raise plumbing.convert_error_to_porcelain(e) from e 4643 break 4644 4645 resp = models.ProxyClusterKeyCreateResponse() 4646 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4647 plumbing_response.meta) 4648 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4649 plumbing_response.proxy_cluster_key) 4650 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4651 plumbing_response.rate_limit) 4652 resp.secret_key = (plumbing_response.secret_key) 4653 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
4655 def get(self, id, timeout=None): 4656 ''' 4657 Get reads one ProxyClusterKey by ID. 4658 ''' 4659 deadline = None if timeout is None else time.time() + timeout 4660 req = ProxyClusterKeyGetRequest() 4661 if self.parent.snapshot_datetime is not None: 4662 req.meta.CopyFrom(GetRequestMetadata()) 4663 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4664 4665 req.id = (id) 4666 tries = 0 4667 plumbing_response = None 4668 while True: 4669 t = None if deadline is None else deadline - time.time() 4670 try: 4671 plumbing_response = self.stub.Get( 4672 req, 4673 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4674 req), 4675 timeout=t) 4676 except Exception as e: 4677 if self.parent.shouldRetry(tries, e, deadline): 4678 tries += 1 4679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4680 continue 4681 raise plumbing.convert_error_to_porcelain(e) from e 4682 break 4683 4684 resp = models.ProxyClusterKeyGetResponse() 4685 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4686 plumbing_response.meta) 4687 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4688 plumbing_response.proxy_cluster_key) 4689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4690 plumbing_response.rate_limit) 4691 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
4693 def delete(self, id, timeout=None): 4694 ''' 4695 Delete removes a ProxyClusterKey by ID. 4696 ''' 4697 deadline = None if timeout is None else time.time() + timeout 4698 req = ProxyClusterKeyDeleteRequest() 4699 4700 req.id = (id) 4701 tries = 0 4702 plumbing_response = None 4703 while True: 4704 t = None if deadline is None else deadline - time.time() 4705 try: 4706 plumbing_response = self.stub.Delete( 4707 req, 4708 metadata=self.parent.get_metadata( 4709 'ProxyClusterKeys.Delete', req), 4710 timeout=t) 4711 except Exception as e: 4712 if self.parent.shouldRetry(tries, e, deadline): 4713 tries += 1 4714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4715 continue 4716 raise plumbing.convert_error_to_porcelain(e) from e 4717 break 4718 4719 resp = models.ProxyClusterKeyDeleteResponse() 4720 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4721 plumbing_response.meta) 4722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4723 plumbing_response.rate_limit) 4724 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4726 def list(self, filter, *args, timeout=None): 4727 ''' 4728 List gets a list of ProxyClusterKeys matching a given set of criteria. 4729 ''' 4730 deadline = None if timeout is None else time.time() + timeout 4731 req = ProxyClusterKeyListRequest() 4732 req.meta.CopyFrom(ListRequestMetadata()) 4733 if self.parent.page_limit > 0: 4734 req.meta.limit = self.parent.page_limit 4735 if self.parent.snapshot_datetime is not None: 4736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4737 4738 req.filter = plumbing.quote_filter_args(filter, *args) 4739 4740 def generator(svc, req): 4741 tries = 0 4742 while True: 4743 t = None if deadline is None else deadline - time.time() 4744 try: 4745 plumbing_response = svc.stub.List( 4746 req, 4747 metadata=svc.parent.get_metadata( 4748 'ProxyClusterKeys.List', req), 4749 timeout=t) 4750 except Exception as e: 4751 if self.parent.shouldRetry(tries, e, deadline): 4752 tries += 1 4753 time.sleep( 4754 self.parent.exponentialBackoff(tries, deadline)) 4755 continue 4756 raise plumbing.convert_error_to_porcelain(e) from e 4757 tries = 0 4758 for plumbing_item in plumbing_response.proxy_cluster_keys: 4759 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4760 plumbing_item) 4761 if plumbing_response.meta.next_cursor == '': 4762 break 4763 req.meta.cursor = plumbing_response.meta.next_cursor 4764 4765 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
4768class SnapshotProxyClusterKeys: 4769 ''' 4770 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4771 service for historical queries. 4772 ''' 4773 def __init__(self, proxy_cluster_keys): 4774 self.proxy_cluster_keys = proxy_cluster_keys 4775 4776 def get(self, id, timeout=None): 4777 ''' 4778 Get reads one ProxyClusterKey by ID. 4779 ''' 4780 return self.proxy_cluster_keys.get(id, timeout=timeout) 4781 4782 def list(self, filter, *args, timeout=None): 4783 ''' 4784 List gets a list of ProxyClusterKeys matching a given set of criteria. 4785 ''' 4786 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)
4776 def get(self, id, timeout=None): 4777 ''' 4778 Get reads one ProxyClusterKey by ID. 4779 ''' 4780 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4782 def list(self, filter, *args, timeout=None): 4783 ''' 4784 List gets a list of ProxyClusterKeys matching a given set of criteria. 4785 ''' 4786 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
4789class Queries: 4790 ''' 4791 A Query is a record of a single client request to a resource, such as a SQL query. 4792 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4793 The Queries service is read-only. 4794 See `strongdm.models.Query`. 4795 ''' 4796 def __init__(self, channel, client): 4797 self.parent = client 4798 self.stub = QueriesStub(channel) 4799 4800 def list(self, filter, *args, timeout=None): 4801 ''' 4802 List gets a list of Queries matching a given set of criteria. 4803 ''' 4804 deadline = None if timeout is None else time.time() + timeout 4805 req = QueryListRequest() 4806 req.meta.CopyFrom(ListRequestMetadata()) 4807 if self.parent.page_limit > 0: 4808 req.meta.limit = self.parent.page_limit 4809 if self.parent.snapshot_datetime is not None: 4810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4811 4812 req.filter = plumbing.quote_filter_args(filter, *args) 4813 4814 def generator(svc, req): 4815 tries = 0 4816 while True: 4817 t = None if deadline is None else deadline - time.time() 4818 try: 4819 plumbing_response = svc.stub.List( 4820 req, 4821 metadata=svc.parent.get_metadata('Queries.List', req), 4822 timeout=t) 4823 except Exception as e: 4824 if self.parent.shouldRetry(tries, e, deadline): 4825 tries += 1 4826 time.sleep( 4827 self.parent.exponentialBackoff(tries, deadline)) 4828 continue 4829 raise plumbing.convert_error_to_porcelain(e) from e 4830 tries = 0 4831 for plumbing_item in plumbing_response.queries: 4832 yield plumbing.convert_query_to_porcelain(plumbing_item) 4833 if plumbing_response.meta.next_cursor == '': 4834 break 4835 req.meta.cursor = plumbing_response.meta.next_cursor 4836 4837 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)
4800 def list(self, filter, *args, timeout=None): 4801 ''' 4802 List gets a list of Queries matching a given set of criteria. 4803 ''' 4804 deadline = None if timeout is None else time.time() + timeout 4805 req = QueryListRequest() 4806 req.meta.CopyFrom(ListRequestMetadata()) 4807 if self.parent.page_limit > 0: 4808 req.meta.limit = self.parent.page_limit 4809 if self.parent.snapshot_datetime is not None: 4810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4811 4812 req.filter = plumbing.quote_filter_args(filter, *args) 4813 4814 def generator(svc, req): 4815 tries = 0 4816 while True: 4817 t = None if deadline is None else deadline - time.time() 4818 try: 4819 plumbing_response = svc.stub.List( 4820 req, 4821 metadata=svc.parent.get_metadata('Queries.List', req), 4822 timeout=t) 4823 except Exception as e: 4824 if self.parent.shouldRetry(tries, e, deadline): 4825 tries += 1 4826 time.sleep( 4827 self.parent.exponentialBackoff(tries, deadline)) 4828 continue 4829 raise plumbing.convert_error_to_porcelain(e) from e 4830 tries = 0 4831 for plumbing_item in plumbing_response.queries: 4832 yield plumbing.convert_query_to_porcelain(plumbing_item) 4833 if plumbing_response.meta.next_cursor == '': 4834 break 4835 req.meta.cursor = plumbing_response.meta.next_cursor 4836 4837 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
4840class RemoteIdentities: 4841 ''' 4842 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4843 See `strongdm.models.RemoteIdentity`. 4844 ''' 4845 def __init__(self, channel, client): 4846 self.parent = client 4847 self.stub = RemoteIdentitiesStub(channel) 4848 4849 def create(self, remote_identity, timeout=None): 4850 ''' 4851 Create registers a new RemoteIdentity. 4852 ''' 4853 deadline = None if timeout is None else time.time() + timeout 4854 req = RemoteIdentityCreateRequest() 4855 4856 if remote_identity is not None: 4857 req.remote_identity.CopyFrom( 4858 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4859 tries = 0 4860 plumbing_response = None 4861 while True: 4862 t = None if deadline is None else deadline - time.time() 4863 try: 4864 plumbing_response = self.stub.Create( 4865 req, 4866 metadata=self.parent.get_metadata( 4867 'RemoteIdentities.Create', req), 4868 timeout=t) 4869 except Exception as e: 4870 if self.parent.shouldRetry(tries, e, deadline): 4871 tries += 1 4872 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4873 continue 4874 raise plumbing.convert_error_to_porcelain(e) from e 4875 break 4876 4877 resp = models.RemoteIdentityCreateResponse() 4878 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4879 plumbing_response.meta) 4880 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4881 plumbing_response.rate_limit) 4882 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4883 plumbing_response.remote_identity) 4884 return resp 4885 4886 def get(self, id, timeout=None): 4887 ''' 4888 Get reads one RemoteIdentity by ID. 4889 ''' 4890 deadline = None if timeout is None else time.time() + timeout 4891 req = RemoteIdentityGetRequest() 4892 if self.parent.snapshot_datetime is not None: 4893 req.meta.CopyFrom(GetRequestMetadata()) 4894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4895 4896 req.id = (id) 4897 tries = 0 4898 plumbing_response = None 4899 while True: 4900 t = None if deadline is None else deadline - time.time() 4901 try: 4902 plumbing_response = self.stub.Get( 4903 req, 4904 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4905 req), 4906 timeout=t) 4907 except Exception as e: 4908 if self.parent.shouldRetry(tries, e, deadline): 4909 tries += 1 4910 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4911 continue 4912 raise plumbing.convert_error_to_porcelain(e) from e 4913 break 4914 4915 resp = models.RemoteIdentityGetResponse() 4916 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4917 plumbing_response.meta) 4918 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4919 plumbing_response.rate_limit) 4920 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4921 plumbing_response.remote_identity) 4922 return resp 4923 4924 def update(self, remote_identity, timeout=None): 4925 ''' 4926 Update replaces all the fields of a RemoteIdentity by ID. 4927 ''' 4928 deadline = None if timeout is None else time.time() + timeout 4929 req = RemoteIdentityUpdateRequest() 4930 4931 if remote_identity is not None: 4932 req.remote_identity.CopyFrom( 4933 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4934 tries = 0 4935 plumbing_response = None 4936 while True: 4937 t = None if deadline is None else deadline - time.time() 4938 try: 4939 plumbing_response = self.stub.Update( 4940 req, 4941 metadata=self.parent.get_metadata( 4942 'RemoteIdentities.Update', req), 4943 timeout=t) 4944 except Exception as e: 4945 if self.parent.shouldRetry(tries, e, deadline): 4946 tries += 1 4947 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4948 continue 4949 raise plumbing.convert_error_to_porcelain(e) from e 4950 break 4951 4952 resp = models.RemoteIdentityUpdateResponse() 4953 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4954 plumbing_response.meta) 4955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4956 plumbing_response.rate_limit) 4957 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4958 plumbing_response.remote_identity) 4959 return resp 4960 4961 def delete(self, id, timeout=None): 4962 ''' 4963 Delete removes a RemoteIdentity by ID. 4964 ''' 4965 deadline = None if timeout is None else time.time() + timeout 4966 req = RemoteIdentityDeleteRequest() 4967 4968 req.id = (id) 4969 tries = 0 4970 plumbing_response = None 4971 while True: 4972 t = None if deadline is None else deadline - time.time() 4973 try: 4974 plumbing_response = self.stub.Delete( 4975 req, 4976 metadata=self.parent.get_metadata( 4977 'RemoteIdentities.Delete', req), 4978 timeout=t) 4979 except Exception as e: 4980 if self.parent.shouldRetry(tries, e, deadline): 4981 tries += 1 4982 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4983 continue 4984 raise plumbing.convert_error_to_porcelain(e) from e 4985 break 4986 4987 resp = models.RemoteIdentityDeleteResponse() 4988 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4989 plumbing_response.meta) 4990 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4991 plumbing_response.rate_limit) 4992 return resp 4993 4994 def list(self, filter, *args, timeout=None): 4995 ''' 4996 List gets a list of RemoteIdentities matching a given set of criteria. 4997 ''' 4998 deadline = None if timeout is None else time.time() + timeout 4999 req = RemoteIdentityListRequest() 5000 req.meta.CopyFrom(ListRequestMetadata()) 5001 if self.parent.page_limit > 0: 5002 req.meta.limit = self.parent.page_limit 5003 if self.parent.snapshot_datetime is not None: 5004 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5005 5006 req.filter = plumbing.quote_filter_args(filter, *args) 5007 5008 def generator(svc, req): 5009 tries = 0 5010 while True: 5011 t = None if deadline is None else deadline - time.time() 5012 try: 5013 plumbing_response = svc.stub.List( 5014 req, 5015 metadata=svc.parent.get_metadata( 5016 'RemoteIdentities.List', req), 5017 timeout=t) 5018 except Exception as e: 5019 if self.parent.shouldRetry(tries, e, deadline): 5020 tries += 1 5021 time.sleep( 5022 self.parent.exponentialBackoff(tries, deadline)) 5023 continue 5024 raise plumbing.convert_error_to_porcelain(e) from e 5025 tries = 0 5026 for plumbing_item in plumbing_response.remote_identities: 5027 yield plumbing.convert_remote_identity_to_porcelain( 5028 plumbing_item) 5029 if plumbing_response.meta.next_cursor == '': 5030 break 5031 req.meta.cursor = plumbing_response.meta.next_cursor 5032 5033 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)
4849 def create(self, remote_identity, timeout=None): 4850 ''' 4851 Create registers a new RemoteIdentity. 4852 ''' 4853 deadline = None if timeout is None else time.time() + timeout 4854 req = RemoteIdentityCreateRequest() 4855 4856 if remote_identity is not None: 4857 req.remote_identity.CopyFrom( 4858 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4859 tries = 0 4860 plumbing_response = None 4861 while True: 4862 t = None if deadline is None else deadline - time.time() 4863 try: 4864 plumbing_response = self.stub.Create( 4865 req, 4866 metadata=self.parent.get_metadata( 4867 'RemoteIdentities.Create', req), 4868 timeout=t) 4869 except Exception as e: 4870 if self.parent.shouldRetry(tries, e, deadline): 4871 tries += 1 4872 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4873 continue 4874 raise plumbing.convert_error_to_porcelain(e) from e 4875 break 4876 4877 resp = models.RemoteIdentityCreateResponse() 4878 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4879 plumbing_response.meta) 4880 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4881 plumbing_response.rate_limit) 4882 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4883 plumbing_response.remote_identity) 4884 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
4886 def get(self, id, timeout=None): 4887 ''' 4888 Get reads one RemoteIdentity by ID. 4889 ''' 4890 deadline = None if timeout is None else time.time() + timeout 4891 req = RemoteIdentityGetRequest() 4892 if self.parent.snapshot_datetime is not None: 4893 req.meta.CopyFrom(GetRequestMetadata()) 4894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4895 4896 req.id = (id) 4897 tries = 0 4898 plumbing_response = None 4899 while True: 4900 t = None if deadline is None else deadline - time.time() 4901 try: 4902 plumbing_response = self.stub.Get( 4903 req, 4904 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4905 req), 4906 timeout=t) 4907 except Exception as e: 4908 if self.parent.shouldRetry(tries, e, deadline): 4909 tries += 1 4910 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4911 continue 4912 raise plumbing.convert_error_to_porcelain(e) from e 4913 break 4914 4915 resp = models.RemoteIdentityGetResponse() 4916 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4917 plumbing_response.meta) 4918 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4919 plumbing_response.rate_limit) 4920 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4921 plumbing_response.remote_identity) 4922 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
4924 def update(self, remote_identity, timeout=None): 4925 ''' 4926 Update replaces all the fields of a RemoteIdentity by ID. 4927 ''' 4928 deadline = None if timeout is None else time.time() + timeout 4929 req = RemoteIdentityUpdateRequest() 4930 4931 if remote_identity is not None: 4932 req.remote_identity.CopyFrom( 4933 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4934 tries = 0 4935 plumbing_response = None 4936 while True: 4937 t = None if deadline is None else deadline - time.time() 4938 try: 4939 plumbing_response = self.stub.Update( 4940 req, 4941 metadata=self.parent.get_metadata( 4942 'RemoteIdentities.Update', req), 4943 timeout=t) 4944 except Exception as e: 4945 if self.parent.shouldRetry(tries, e, deadline): 4946 tries += 1 4947 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4948 continue 4949 raise plumbing.convert_error_to_porcelain(e) from e 4950 break 4951 4952 resp = models.RemoteIdentityUpdateResponse() 4953 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4954 plumbing_response.meta) 4955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4956 plumbing_response.rate_limit) 4957 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4958 plumbing_response.remote_identity) 4959 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
4961 def delete(self, id, timeout=None): 4962 ''' 4963 Delete removes a RemoteIdentity by ID. 4964 ''' 4965 deadline = None if timeout is None else time.time() + timeout 4966 req = RemoteIdentityDeleteRequest() 4967 4968 req.id = (id) 4969 tries = 0 4970 plumbing_response = None 4971 while True: 4972 t = None if deadline is None else deadline - time.time() 4973 try: 4974 plumbing_response = self.stub.Delete( 4975 req, 4976 metadata=self.parent.get_metadata( 4977 'RemoteIdentities.Delete', req), 4978 timeout=t) 4979 except Exception as e: 4980 if self.parent.shouldRetry(tries, e, deadline): 4981 tries += 1 4982 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4983 continue 4984 raise plumbing.convert_error_to_porcelain(e) from e 4985 break 4986 4987 resp = models.RemoteIdentityDeleteResponse() 4988 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4989 plumbing_response.meta) 4990 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4991 plumbing_response.rate_limit) 4992 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
4994 def list(self, filter, *args, timeout=None): 4995 ''' 4996 List gets a list of RemoteIdentities matching a given set of criteria. 4997 ''' 4998 deadline = None if timeout is None else time.time() + timeout 4999 req = RemoteIdentityListRequest() 5000 req.meta.CopyFrom(ListRequestMetadata()) 5001 if self.parent.page_limit > 0: 5002 req.meta.limit = self.parent.page_limit 5003 if self.parent.snapshot_datetime is not None: 5004 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5005 5006 req.filter = plumbing.quote_filter_args(filter, *args) 5007 5008 def generator(svc, req): 5009 tries = 0 5010 while True: 5011 t = None if deadline is None else deadline - time.time() 5012 try: 5013 plumbing_response = svc.stub.List( 5014 req, 5015 metadata=svc.parent.get_metadata( 5016 'RemoteIdentities.List', req), 5017 timeout=t) 5018 except Exception as e: 5019 if self.parent.shouldRetry(tries, e, deadline): 5020 tries += 1 5021 time.sleep( 5022 self.parent.exponentialBackoff(tries, deadline)) 5023 continue 5024 raise plumbing.convert_error_to_porcelain(e) from e 5025 tries = 0 5026 for plumbing_item in plumbing_response.remote_identities: 5027 yield plumbing.convert_remote_identity_to_porcelain( 5028 plumbing_item) 5029 if plumbing_response.meta.next_cursor == '': 5030 break 5031 req.meta.cursor = plumbing_response.meta.next_cursor 5032 5033 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
5036class SnapshotRemoteIdentities: 5037 ''' 5038 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5039 service for historical queries. 5040 ''' 5041 def __init__(self, remote_identities): 5042 self.remote_identities = remote_identities 5043 5044 def get(self, id, timeout=None): 5045 ''' 5046 Get reads one RemoteIdentity by ID. 5047 ''' 5048 return self.remote_identities.get(id, timeout=timeout) 5049 5050 def list(self, filter, *args, timeout=None): 5051 ''' 5052 List gets a list of RemoteIdentities matching a given set of criteria. 5053 ''' 5054 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)
5044 def get(self, id, timeout=None): 5045 ''' 5046 Get reads one RemoteIdentity by ID. 5047 ''' 5048 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
5050 def list(self, filter, *args, timeout=None): 5051 ''' 5052 List gets a list of RemoteIdentities matching a given set of criteria. 5053 ''' 5054 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
5057class RemoteIdentitiesHistory: 5058 ''' 5059 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5060 See `strongdm.models.RemoteIdentityHistory`. 5061 ''' 5062 def __init__(self, channel, client): 5063 self.parent = client 5064 self.stub = RemoteIdentitiesHistoryStub(channel) 5065 5066 def list(self, filter, *args, timeout=None): 5067 ''' 5068 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5069 ''' 5070 deadline = None if timeout is None else time.time() + timeout 5071 req = RemoteIdentityHistoryListRequest() 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 'RemoteIdentitiesHistory.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.history: 5099 yield plumbing.convert_remote_identity_history_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)
RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity.
See strongdm.models.RemoteIdentityHistory.
def
list(self, filter, *args, timeout=None)
5066 def list(self, filter, *args, timeout=None): 5067 ''' 5068 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5069 ''' 5070 deadline = None if timeout is None else time.time() + timeout 5071 req = RemoteIdentityHistoryListRequest() 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 'RemoteIdentitiesHistory.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.history: 5099 yield plumbing.convert_remote_identity_history_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 RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
5108class RemoteIdentityGroups: 5109 ''' 5110 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5111 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5112 See `strongdm.models.RemoteIdentityGroup`. 5113 ''' 5114 def __init__(self, channel, client): 5115 self.parent = client 5116 self.stub = RemoteIdentityGroupsStub(channel) 5117 5118 def get(self, id, timeout=None): 5119 ''' 5120 Get reads one RemoteIdentityGroup by ID. 5121 ''' 5122 deadline = None if timeout is None else time.time() + timeout 5123 req = RemoteIdentityGroupGetRequest() 5124 if self.parent.snapshot_datetime is not None: 5125 req.meta.CopyFrom(GetRequestMetadata()) 5126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5127 5128 req.id = (id) 5129 tries = 0 5130 plumbing_response = None 5131 while True: 5132 t = None if deadline is None else deadline - time.time() 5133 try: 5134 plumbing_response = self.stub.Get( 5135 req, 5136 metadata=self.parent.get_metadata( 5137 'RemoteIdentityGroups.Get', req), 5138 timeout=t) 5139 except Exception as e: 5140 if self.parent.shouldRetry(tries, e, deadline): 5141 tries += 1 5142 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5143 continue 5144 raise plumbing.convert_error_to_porcelain(e) from e 5145 break 5146 5147 resp = models.RemoteIdentityGroupGetResponse() 5148 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5149 plumbing_response.meta) 5150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5151 plumbing_response.rate_limit) 5152 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5153 plumbing_response.remote_identity_group) 5154 return resp 5155 5156 def list(self, filter, *args, timeout=None): 5157 ''' 5158 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5159 ''' 5160 deadline = None if timeout is None else time.time() + timeout 5161 req = RemoteIdentityGroupListRequest() 5162 req.meta.CopyFrom(ListRequestMetadata()) 5163 if self.parent.page_limit > 0: 5164 req.meta.limit = self.parent.page_limit 5165 if self.parent.snapshot_datetime is not None: 5166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5167 5168 req.filter = plumbing.quote_filter_args(filter, *args) 5169 5170 def generator(svc, req): 5171 tries = 0 5172 while True: 5173 t = None if deadline is None else deadline - time.time() 5174 try: 5175 plumbing_response = svc.stub.List( 5176 req, 5177 metadata=svc.parent.get_metadata( 5178 'RemoteIdentityGroups.List', req), 5179 timeout=t) 5180 except Exception as e: 5181 if self.parent.shouldRetry(tries, e, deadline): 5182 tries += 1 5183 time.sleep( 5184 self.parent.exponentialBackoff(tries, deadline)) 5185 continue 5186 raise plumbing.convert_error_to_porcelain(e) from e 5187 tries = 0 5188 for plumbing_item in plumbing_response.remote_identity_groups: 5189 yield plumbing.convert_remote_identity_group_to_porcelain( 5190 plumbing_item) 5191 if plumbing_response.meta.next_cursor == '': 5192 break 5193 req.meta.cursor = plumbing_response.meta.next_cursor 5194 5195 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)
5118 def get(self, id, timeout=None): 5119 ''' 5120 Get reads one RemoteIdentityGroup by ID. 5121 ''' 5122 deadline = None if timeout is None else time.time() + timeout 5123 req = RemoteIdentityGroupGetRequest() 5124 if self.parent.snapshot_datetime is not None: 5125 req.meta.CopyFrom(GetRequestMetadata()) 5126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5127 5128 req.id = (id) 5129 tries = 0 5130 plumbing_response = None 5131 while True: 5132 t = None if deadline is None else deadline - time.time() 5133 try: 5134 plumbing_response = self.stub.Get( 5135 req, 5136 metadata=self.parent.get_metadata( 5137 'RemoteIdentityGroups.Get', req), 5138 timeout=t) 5139 except Exception as e: 5140 if self.parent.shouldRetry(tries, e, deadline): 5141 tries += 1 5142 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5143 continue 5144 raise plumbing.convert_error_to_porcelain(e) from e 5145 break 5146 5147 resp = models.RemoteIdentityGroupGetResponse() 5148 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5149 plumbing_response.meta) 5150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5151 plumbing_response.rate_limit) 5152 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5153 plumbing_response.remote_identity_group) 5154 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
5156 def list(self, filter, *args, timeout=None): 5157 ''' 5158 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5159 ''' 5160 deadline = None if timeout is None else time.time() + timeout 5161 req = RemoteIdentityGroupListRequest() 5162 req.meta.CopyFrom(ListRequestMetadata()) 5163 if self.parent.page_limit > 0: 5164 req.meta.limit = self.parent.page_limit 5165 if self.parent.snapshot_datetime is not None: 5166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5167 5168 req.filter = plumbing.quote_filter_args(filter, *args) 5169 5170 def generator(svc, req): 5171 tries = 0 5172 while True: 5173 t = None if deadline is None else deadline - time.time() 5174 try: 5175 plumbing_response = svc.stub.List( 5176 req, 5177 metadata=svc.parent.get_metadata( 5178 'RemoteIdentityGroups.List', req), 5179 timeout=t) 5180 except Exception as e: 5181 if self.parent.shouldRetry(tries, e, deadline): 5182 tries += 1 5183 time.sleep( 5184 self.parent.exponentialBackoff(tries, deadline)) 5185 continue 5186 raise plumbing.convert_error_to_porcelain(e) from e 5187 tries = 0 5188 for plumbing_item in plumbing_response.remote_identity_groups: 5189 yield plumbing.convert_remote_identity_group_to_porcelain( 5190 plumbing_item) 5191 if plumbing_response.meta.next_cursor == '': 5192 break 5193 req.meta.cursor = plumbing_response.meta.next_cursor 5194 5195 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
5198class SnapshotRemoteIdentityGroups: 5199 ''' 5200 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5201 service for historical queries. 5202 ''' 5203 def __init__(self, remote_identity_groups): 5204 self.remote_identity_groups = remote_identity_groups 5205 5206 def get(self, id, timeout=None): 5207 ''' 5208 Get reads one RemoteIdentityGroup by ID. 5209 ''' 5210 return self.remote_identity_groups.get(id, timeout=timeout) 5211 5212 def list(self, filter, *args, timeout=None): 5213 ''' 5214 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5215 ''' 5216 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)
5206 def get(self, id, timeout=None): 5207 ''' 5208 Get reads one RemoteIdentityGroup by ID. 5209 ''' 5210 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
5212 def list(self, filter, *args, timeout=None): 5213 ''' 5214 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5215 ''' 5216 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
5219class RemoteIdentityGroupsHistory: 5220 ''' 5221 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 5222 See `strongdm.models.RemoteIdentityGroupHistory`. 5223 ''' 5224 def __init__(self, channel, client): 5225 self.parent = client 5226 self.stub = RemoteIdentityGroupsHistoryStub(channel) 5227 5228 def list(self, filter, *args, timeout=None): 5229 ''' 5230 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5231 ''' 5232 deadline = None if timeout is None else time.time() + timeout 5233 req = RemoteIdentityGroupHistoryListRequest() 5234 req.meta.CopyFrom(ListRequestMetadata()) 5235 if self.parent.page_limit > 0: 5236 req.meta.limit = self.parent.page_limit 5237 if self.parent.snapshot_datetime is not None: 5238 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5239 5240 req.filter = plumbing.quote_filter_args(filter, *args) 5241 5242 def generator(svc, req): 5243 tries = 0 5244 while True: 5245 t = None if deadline is None else deadline - time.time() 5246 try: 5247 plumbing_response = svc.stub.List( 5248 req, 5249 metadata=svc.parent.get_metadata( 5250 'RemoteIdentityGroupsHistory.List', req), 5251 timeout=t) 5252 except Exception as e: 5253 if self.parent.shouldRetry(tries, e, deadline): 5254 tries += 1 5255 time.sleep( 5256 self.parent.exponentialBackoff(tries, deadline)) 5257 continue 5258 raise plumbing.convert_error_to_porcelain(e) from e 5259 tries = 0 5260 for plumbing_item in plumbing_response.history: 5261 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5262 plumbing_item) 5263 if plumbing_response.meta.next_cursor == '': 5264 break 5265 req.meta.cursor = plumbing_response.meta.next_cursor 5266 5267 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)
5228 def list(self, filter, *args, timeout=None): 5229 ''' 5230 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 5231 ''' 5232 deadline = None if timeout is None else time.time() + timeout 5233 req = RemoteIdentityGroupHistoryListRequest() 5234 req.meta.CopyFrom(ListRequestMetadata()) 5235 if self.parent.page_limit > 0: 5236 req.meta.limit = self.parent.page_limit 5237 if self.parent.snapshot_datetime is not None: 5238 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5239 5240 req.filter = plumbing.quote_filter_args(filter, *args) 5241 5242 def generator(svc, req): 5243 tries = 0 5244 while True: 5245 t = None if deadline is None else deadline - time.time() 5246 try: 5247 plumbing_response = svc.stub.List( 5248 req, 5249 metadata=svc.parent.get_metadata( 5250 'RemoteIdentityGroupsHistory.List', req), 5251 timeout=t) 5252 except Exception as e: 5253 if self.parent.shouldRetry(tries, e, deadline): 5254 tries += 1 5255 time.sleep( 5256 self.parent.exponentialBackoff(tries, deadline)) 5257 continue 5258 raise plumbing.convert_error_to_porcelain(e) from e 5259 tries = 0 5260 for plumbing_item in plumbing_response.history: 5261 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5262 plumbing_item) 5263 if plumbing_response.meta.next_cursor == '': 5264 break 5265 req.meta.cursor = plumbing_response.meta.next_cursor 5266 5267 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
5270class Replays: 5271 ''' 5272 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5273 (otherwise referred to as a query). The Replays service is read-only. 5274 See `strongdm.models.ReplayChunk`. 5275 ''' 5276 def __init__(self, channel, client): 5277 self.parent = client 5278 self.stub = ReplaysStub(channel) 5279 5280 def list(self, filter, *args, timeout=None): 5281 ''' 5282 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5283 ''' 5284 deadline = None if timeout is None else time.time() + timeout 5285 req = ReplayListRequest() 5286 req.meta.CopyFrom(ListRequestMetadata()) 5287 if self.parent.page_limit > 0: 5288 req.meta.limit = self.parent.page_limit 5289 if self.parent.snapshot_datetime is not None: 5290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5291 5292 req.filter = plumbing.quote_filter_args(filter, *args) 5293 5294 def generator(svc, req): 5295 tries = 0 5296 while True: 5297 t = None if deadline is None else deadline - time.time() 5298 try: 5299 plumbing_response = svc.stub.List( 5300 req, 5301 metadata=svc.parent.get_metadata('Replays.List', req), 5302 timeout=t) 5303 except Exception as e: 5304 if self.parent.shouldRetry(tries, e, deadline): 5305 tries += 1 5306 time.sleep( 5307 self.parent.exponentialBackoff(tries, deadline)) 5308 continue 5309 raise plumbing.convert_error_to_porcelain(e) from e 5310 tries = 0 5311 for plumbing_item in plumbing_response.chunks: 5312 yield plumbing.convert_replay_chunk_to_porcelain( 5313 plumbing_item) 5314 if plumbing_response.meta.next_cursor == '': 5315 break 5316 req.meta.cursor = plumbing_response.meta.next_cursor 5317 5318 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)
5280 def list(self, filter, *args, timeout=None): 5281 ''' 5282 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5283 ''' 5284 deadline = None if timeout is None else time.time() + timeout 5285 req = ReplayListRequest() 5286 req.meta.CopyFrom(ListRequestMetadata()) 5287 if self.parent.page_limit > 0: 5288 req.meta.limit = self.parent.page_limit 5289 if self.parent.snapshot_datetime is not None: 5290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5291 5292 req.filter = plumbing.quote_filter_args(filter, *args) 5293 5294 def generator(svc, req): 5295 tries = 0 5296 while True: 5297 t = None if deadline is None else deadline - time.time() 5298 try: 5299 plumbing_response = svc.stub.List( 5300 req, 5301 metadata=svc.parent.get_metadata('Replays.List', req), 5302 timeout=t) 5303 except Exception as e: 5304 if self.parent.shouldRetry(tries, e, deadline): 5305 tries += 1 5306 time.sleep( 5307 self.parent.exponentialBackoff(tries, deadline)) 5308 continue 5309 raise plumbing.convert_error_to_porcelain(e) from e 5310 tries = 0 5311 for plumbing_item in plumbing_response.chunks: 5312 yield plumbing.convert_replay_chunk_to_porcelain( 5313 plumbing_item) 5314 if plumbing_response.meta.next_cursor == '': 5315 break 5316 req.meta.cursor = plumbing_response.meta.next_cursor 5317 5318 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
5321class Resources: 5322 ''' 5323 Resources are databases, servers, clusters, websites, or clouds that strongDM 5324 delegates access to. 5325 See: 5326 `strongdm.models.Aerospike` 5327 `strongdm.models.AKS` 5328 `strongdm.models.AKSBasicAuth` 5329 `strongdm.models.AKSServiceAccount` 5330 `strongdm.models.AKSServiceAccountUserImpersonation` 5331 `strongdm.models.AKSUserImpersonation` 5332 `strongdm.models.AmazonEKS` 5333 `strongdm.models.AmazonEKSInstanceProfile` 5334 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5335 `strongdm.models.AmazonEKSUserImpersonation` 5336 `strongdm.models.AmazonES` 5337 `strongdm.models.AmazonESIAM` 5338 `strongdm.models.AmazonMQAMQP091` 5339 `strongdm.models.AMQP` 5340 `strongdm.models.Athena` 5341 `strongdm.models.AthenaIAM` 5342 `strongdm.models.AuroraMysql` 5343 `strongdm.models.AuroraMysqlIAM` 5344 `strongdm.models.AuroraPostgres` 5345 `strongdm.models.AuroraPostgresIAM` 5346 `strongdm.models.AWS` 5347 `strongdm.models.AWSConsole` 5348 `strongdm.models.AWSConsoleStaticKeyPair` 5349 `strongdm.models.AWSInstanceProfile` 5350 `strongdm.models.Azure` 5351 `strongdm.models.AzureCertificate` 5352 `strongdm.models.AzureConsole` 5353 `strongdm.models.AzureMysql` 5354 `strongdm.models.AzureMysqlManagedIdentity` 5355 `strongdm.models.AzurePostgres` 5356 `strongdm.models.AzurePostgresManagedIdentity` 5357 `strongdm.models.BigQuery` 5358 `strongdm.models.Cassandra` 5359 `strongdm.models.Citus` 5360 `strongdm.models.ClickHouseHTTP` 5361 `strongdm.models.ClickHouseMySQL` 5362 `strongdm.models.ClickHouseTCP` 5363 `strongdm.models.Clustrix` 5364 `strongdm.models.Cockroach` 5365 `strongdm.models.CouchbaseDatabase` 5366 `strongdm.models.CouchbaseWebUI` 5367 `strongdm.models.DB2I` 5368 `strongdm.models.DB2LUW` 5369 `strongdm.models.DocumentDBHost` 5370 `strongdm.models.DocumentDBHostIAM` 5371 `strongdm.models.DocumentDBReplicaSet` 5372 `strongdm.models.DocumentDBReplicaSetIAM` 5373 `strongdm.models.Druid` 5374 `strongdm.models.DynamoDB` 5375 `strongdm.models.DynamoDBIAM` 5376 `strongdm.models.Elastic` 5377 `strongdm.models.ElasticacheRedis` 5378 `strongdm.models.GCP` 5379 `strongdm.models.GCPConsole` 5380 `strongdm.models.GCPWIF` 5381 `strongdm.models.GoogleGKE` 5382 `strongdm.models.GoogleGKEUserImpersonation` 5383 `strongdm.models.Greenplum` 5384 `strongdm.models.HTTPAuth` 5385 `strongdm.models.HTTPBasicAuth` 5386 `strongdm.models.HTTPNoAuth` 5387 `strongdm.models.Kubernetes` 5388 `strongdm.models.KubernetesBasicAuth` 5389 `strongdm.models.KubernetesPodIdentity` 5390 `strongdm.models.KubernetesServiceAccount` 5391 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5392 `strongdm.models.KubernetesUserImpersonation` 5393 `strongdm.models.Maria` 5394 `strongdm.models.Memcached` 5395 `strongdm.models.Memsql` 5396 `strongdm.models.MongoHost` 5397 `strongdm.models.MongoLegacyHost` 5398 `strongdm.models.MongoLegacyReplicaset` 5399 `strongdm.models.MongoReplicaSet` 5400 `strongdm.models.MongoShardedCluster` 5401 `strongdm.models.MTLSMysql` 5402 `strongdm.models.MTLSPostgres` 5403 `strongdm.models.Mysql` 5404 `strongdm.models.Neptune` 5405 `strongdm.models.NeptuneIAM` 5406 `strongdm.models.Oracle` 5407 `strongdm.models.OracleNNE` 5408 `strongdm.models.Postgres` 5409 `strongdm.models.Presto` 5410 `strongdm.models.RabbitMQAMQP091` 5411 `strongdm.models.RawTCP` 5412 `strongdm.models.RDP` 5413 `strongdm.models.RDPCert` 5414 `strongdm.models.RDSPostgresIAM` 5415 `strongdm.models.Redis` 5416 `strongdm.models.RedisCluster` 5417 `strongdm.models.Redshift` 5418 `strongdm.models.RedshiftIAM` 5419 `strongdm.models.RedshiftServerlessIAM` 5420 `strongdm.models.SingleStore` 5421 `strongdm.models.Snowflake` 5422 `strongdm.models.Snowsight` 5423 `strongdm.models.SQLServer` 5424 `strongdm.models.SQLServerAzureAD` 5425 `strongdm.models.SQLServerKerberosAD` 5426 `strongdm.models.SSH` 5427 `strongdm.models.SSHCert` 5428 `strongdm.models.SSHCustomerKey` 5429 `strongdm.models.SSHPassword` 5430 `strongdm.models.Sybase` 5431 `strongdm.models.SybaseIQ` 5432 `strongdm.models.Teradata` 5433 `strongdm.models.Trino` 5434 `strongdm.models.Vertica` 5435 ''' 5436 def __init__(self, channel, client): 5437 self.parent = client 5438 self.stub = ResourcesStub(channel) 5439 5440 def enumerate_tags(self, filter, *args, timeout=None): 5441 ''' 5442 EnumerateTags gets a list of the filter matching tags. 5443 ''' 5444 deadline = None if timeout is None else time.time() + timeout 5445 req = EnumerateTagsRequest() 5446 req.meta.CopyFrom(ListRequestMetadata()) 5447 if self.parent.page_limit > 0: 5448 req.meta.limit = self.parent.page_limit 5449 if self.parent.snapshot_datetime is not None: 5450 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5451 5452 req.filter = plumbing.quote_filter_args(filter, *args) 5453 5454 def generator(svc, req): 5455 tries = 0 5456 while True: 5457 t = None if deadline is None else deadline - time.time() 5458 try: 5459 plumbing_response = svc.stub.EnumerateTags( 5460 req, 5461 metadata=svc.parent.get_metadata( 5462 'Resources.EnumerateTags', req), 5463 timeout=t) 5464 except Exception as e: 5465 if self.parent.shouldRetry(tries, e, deadline): 5466 tries += 1 5467 time.sleep( 5468 self.parent.exponentialBackoff(tries, deadline)) 5469 continue 5470 raise plumbing.convert_error_to_porcelain(e) from e 5471 tries = 0 5472 for plumbing_item in plumbing_response.matches: 5473 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5474 if plumbing_response.meta.next_cursor == '': 5475 break 5476 req.meta.cursor = plumbing_response.meta.next_cursor 5477 5478 return generator(self, req) 5479 5480 def create(self, resource, timeout=None): 5481 ''' 5482 Create registers a new Resource. 5483 ''' 5484 deadline = None if timeout is None else time.time() + timeout 5485 req = ResourceCreateRequest() 5486 5487 if resource is not None: 5488 req.resource.CopyFrom( 5489 plumbing.convert_resource_to_plumbing(resource)) 5490 tries = 0 5491 plumbing_response = None 5492 while True: 5493 t = None if deadline is None else deadline - time.time() 5494 try: 5495 plumbing_response = self.stub.Create( 5496 req, 5497 metadata=self.parent.get_metadata('Resources.Create', req), 5498 timeout=t) 5499 except Exception as e: 5500 if self.parent.shouldRetry(tries, e, deadline): 5501 tries += 1 5502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5503 continue 5504 raise plumbing.convert_error_to_porcelain(e) from e 5505 break 5506 5507 resp = models.ResourceCreateResponse() 5508 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5509 plumbing_response.meta) 5510 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5511 plumbing_response.rate_limit) 5512 resp.resource = plumbing.convert_resource_to_porcelain( 5513 plumbing_response.resource) 5514 return resp 5515 5516 def get(self, id, timeout=None): 5517 ''' 5518 Get reads one Resource by ID. 5519 ''' 5520 deadline = None if timeout is None else time.time() + timeout 5521 req = ResourceGetRequest() 5522 if self.parent.snapshot_datetime is not None: 5523 req.meta.CopyFrom(GetRequestMetadata()) 5524 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5525 5526 req.id = (id) 5527 tries = 0 5528 plumbing_response = None 5529 while True: 5530 t = None if deadline is None else deadline - time.time() 5531 try: 5532 plumbing_response = self.stub.Get( 5533 req, 5534 metadata=self.parent.get_metadata('Resources.Get', req), 5535 timeout=t) 5536 except Exception as e: 5537 if self.parent.shouldRetry(tries, e, deadline): 5538 tries += 1 5539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5540 continue 5541 raise plumbing.convert_error_to_porcelain(e) from e 5542 break 5543 5544 resp = models.ResourceGetResponse() 5545 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5546 plumbing_response.meta) 5547 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5548 plumbing_response.rate_limit) 5549 resp.resource = plumbing.convert_resource_to_porcelain( 5550 plumbing_response.resource) 5551 return resp 5552 5553 def update(self, resource, timeout=None): 5554 ''' 5555 Update replaces all the fields of a Resource by ID. 5556 ''' 5557 deadline = None if timeout is None else time.time() + timeout 5558 req = ResourceUpdateRequest() 5559 5560 if resource is not None: 5561 req.resource.CopyFrom( 5562 plumbing.convert_resource_to_plumbing(resource)) 5563 tries = 0 5564 plumbing_response = None 5565 while True: 5566 t = None if deadline is None else deadline - time.time() 5567 try: 5568 plumbing_response = self.stub.Update( 5569 req, 5570 metadata=self.parent.get_metadata('Resources.Update', req), 5571 timeout=t) 5572 except Exception as e: 5573 if self.parent.shouldRetry(tries, e, deadline): 5574 tries += 1 5575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5576 continue 5577 raise plumbing.convert_error_to_porcelain(e) from e 5578 break 5579 5580 resp = models.ResourceUpdateResponse() 5581 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5582 plumbing_response.meta) 5583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5584 plumbing_response.rate_limit) 5585 resp.resource = plumbing.convert_resource_to_porcelain( 5586 plumbing_response.resource) 5587 return resp 5588 5589 def delete(self, id, timeout=None): 5590 ''' 5591 Delete removes a Resource by ID. 5592 ''' 5593 deadline = None if timeout is None else time.time() + timeout 5594 req = ResourceDeleteRequest() 5595 5596 req.id = (id) 5597 tries = 0 5598 plumbing_response = None 5599 while True: 5600 t = None if deadline is None else deadline - time.time() 5601 try: 5602 plumbing_response = self.stub.Delete( 5603 req, 5604 metadata=self.parent.get_metadata('Resources.Delete', req), 5605 timeout=t) 5606 except Exception as e: 5607 if self.parent.shouldRetry(tries, e, deadline): 5608 tries += 1 5609 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5610 continue 5611 raise plumbing.convert_error_to_porcelain(e) from e 5612 break 5613 5614 resp = models.ResourceDeleteResponse() 5615 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5616 plumbing_response.meta) 5617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5618 plumbing_response.rate_limit) 5619 return resp 5620 5621 def list(self, filter, *args, timeout=None): 5622 ''' 5623 List gets a list of Resources matching a given set of criteria. 5624 ''' 5625 deadline = None if timeout is None else time.time() + timeout 5626 req = ResourceListRequest() 5627 req.meta.CopyFrom(ListRequestMetadata()) 5628 if self.parent.page_limit > 0: 5629 req.meta.limit = self.parent.page_limit 5630 if self.parent.snapshot_datetime is not None: 5631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5632 5633 req.filter = plumbing.quote_filter_args(filter, *args) 5634 5635 def generator(svc, req): 5636 tries = 0 5637 while True: 5638 t = None if deadline is None else deadline - time.time() 5639 try: 5640 plumbing_response = svc.stub.List( 5641 req, 5642 metadata=svc.parent.get_metadata( 5643 'Resources.List', req), 5644 timeout=t) 5645 except Exception as e: 5646 if self.parent.shouldRetry(tries, e, deadline): 5647 tries += 1 5648 time.sleep( 5649 self.parent.exponentialBackoff(tries, deadline)) 5650 continue 5651 raise plumbing.convert_error_to_porcelain(e) from e 5652 tries = 0 5653 for plumbing_item in plumbing_response.resources: 5654 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5655 if plumbing_response.meta.next_cursor == '': 5656 break 5657 req.meta.cursor = plumbing_response.meta.next_cursor 5658 5659 return generator(self, req) 5660 5661 def healthcheck(self, id, timeout=None): 5662 ''' 5663 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5664 large network of Nodes. The call will return immediately, and the updated health of the 5665 Resource can be retrieved via Get or List. 5666 ''' 5667 deadline = None if timeout is None else time.time() + timeout 5668 req = ResourceHealthcheckRequest() 5669 5670 req.id = (id) 5671 tries = 0 5672 plumbing_response = None 5673 while True: 5674 t = None if deadline is None else deadline - time.time() 5675 try: 5676 plumbing_response = self.stub.Healthcheck( 5677 req, 5678 metadata=self.parent.get_metadata('Resources.Healthcheck', 5679 req), 5680 timeout=t) 5681 except Exception as e: 5682 if self.parent.shouldRetry(tries, e, deadline): 5683 tries += 1 5684 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5685 continue 5686 raise plumbing.convert_error_to_porcelain(e) from e 5687 break 5688 5689 resp = models.ResourceHealthcheckResponse() 5690 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5691 plumbing_response.meta) 5692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5693 plumbing_response.rate_limit) 5694 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.AzureConsole
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.GCP
strongdm.models.GCPConsole
strongdm.models.GCPWIF
strongdm.models.GoogleGKE
strongdm.models.GoogleGKEUserImpersonation
strongdm.models.Greenplum
strongdm.models.HTTPAuth
strongdm.models.HTTPBasicAuth
strongdm.models.HTTPNoAuth
strongdm.models.Kubernetes
strongdm.models.KubernetesBasicAuth
strongdm.models.KubernetesPodIdentity
strongdm.models.KubernetesServiceAccount
strongdm.models.KubernetesServiceAccountUserImpersonation
strongdm.models.KubernetesUserImpersonation
strongdm.models.Maria
strongdm.models.Memcached
strongdm.models.Memsql
strongdm.models.MongoHost
strongdm.models.MongoLegacyHost
strongdm.models.MongoLegacyReplicaset
strongdm.models.MongoReplicaSet
strongdm.models.MongoShardedCluster
strongdm.models.MTLSMysql
strongdm.models.MTLSPostgres
strongdm.models.Mysql
strongdm.models.Neptune
strongdm.models.NeptuneIAM
strongdm.models.Oracle
strongdm.models.OracleNNE
strongdm.models.Postgres
strongdm.models.Presto
strongdm.models.RabbitMQAMQP091
strongdm.models.RawTCP
strongdm.models.RDP
strongdm.models.RDPCert
strongdm.models.RDSPostgresIAM
strongdm.models.Redis
strongdm.models.RedisCluster
strongdm.models.Redshift
strongdm.models.RedshiftIAM
strongdm.models.RedshiftServerlessIAM
strongdm.models.SingleStore
strongdm.models.Snowflake
strongdm.models.Snowsight
strongdm.models.SQLServer
strongdm.models.SQLServerAzureAD
strongdm.models.SQLServerKerberosAD
strongdm.models.SSH
strongdm.models.SSHCert
strongdm.models.SSHCustomerKey
strongdm.models.SSHPassword
strongdm.models.Sybase
strongdm.models.SybaseIQ
strongdm.models.Teradata
strongdm.models.Trino
strongdm.models.Vertica
def
create(self, resource, timeout=None)
5480 def create(self, resource, timeout=None): 5481 ''' 5482 Create registers a new Resource. 5483 ''' 5484 deadline = None if timeout is None else time.time() + timeout 5485 req = ResourceCreateRequest() 5486 5487 if resource is not None: 5488 req.resource.CopyFrom( 5489 plumbing.convert_resource_to_plumbing(resource)) 5490 tries = 0 5491 plumbing_response = None 5492 while True: 5493 t = None if deadline is None else deadline - time.time() 5494 try: 5495 plumbing_response = self.stub.Create( 5496 req, 5497 metadata=self.parent.get_metadata('Resources.Create', req), 5498 timeout=t) 5499 except Exception as e: 5500 if self.parent.shouldRetry(tries, e, deadline): 5501 tries += 1 5502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5503 continue 5504 raise plumbing.convert_error_to_porcelain(e) from e 5505 break 5506 5507 resp = models.ResourceCreateResponse() 5508 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5509 plumbing_response.meta) 5510 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5511 plumbing_response.rate_limit) 5512 resp.resource = plumbing.convert_resource_to_porcelain( 5513 plumbing_response.resource) 5514 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
5516 def get(self, id, timeout=None): 5517 ''' 5518 Get reads one Resource by ID. 5519 ''' 5520 deadline = None if timeout is None else time.time() + timeout 5521 req = ResourceGetRequest() 5522 if self.parent.snapshot_datetime is not None: 5523 req.meta.CopyFrom(GetRequestMetadata()) 5524 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5525 5526 req.id = (id) 5527 tries = 0 5528 plumbing_response = None 5529 while True: 5530 t = None if deadline is None else deadline - time.time() 5531 try: 5532 plumbing_response = self.stub.Get( 5533 req, 5534 metadata=self.parent.get_metadata('Resources.Get', req), 5535 timeout=t) 5536 except Exception as e: 5537 if self.parent.shouldRetry(tries, e, deadline): 5538 tries += 1 5539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5540 continue 5541 raise plumbing.convert_error_to_porcelain(e) from e 5542 break 5543 5544 resp = models.ResourceGetResponse() 5545 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5546 plumbing_response.meta) 5547 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5548 plumbing_response.rate_limit) 5549 resp.resource = plumbing.convert_resource_to_porcelain( 5550 plumbing_response.resource) 5551 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
5553 def update(self, resource, timeout=None): 5554 ''' 5555 Update replaces all the fields of a Resource by ID. 5556 ''' 5557 deadline = None if timeout is None else time.time() + timeout 5558 req = ResourceUpdateRequest() 5559 5560 if resource is not None: 5561 req.resource.CopyFrom( 5562 plumbing.convert_resource_to_plumbing(resource)) 5563 tries = 0 5564 plumbing_response = None 5565 while True: 5566 t = None if deadline is None else deadline - time.time() 5567 try: 5568 plumbing_response = self.stub.Update( 5569 req, 5570 metadata=self.parent.get_metadata('Resources.Update', req), 5571 timeout=t) 5572 except Exception as e: 5573 if self.parent.shouldRetry(tries, e, deadline): 5574 tries += 1 5575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5576 continue 5577 raise plumbing.convert_error_to_porcelain(e) from e 5578 break 5579 5580 resp = models.ResourceUpdateResponse() 5581 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5582 plumbing_response.meta) 5583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5584 plumbing_response.rate_limit) 5585 resp.resource = plumbing.convert_resource_to_porcelain( 5586 plumbing_response.resource) 5587 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
5589 def delete(self, id, timeout=None): 5590 ''' 5591 Delete removes a Resource by ID. 5592 ''' 5593 deadline = None if timeout is None else time.time() + timeout 5594 req = ResourceDeleteRequest() 5595 5596 req.id = (id) 5597 tries = 0 5598 plumbing_response = None 5599 while True: 5600 t = None if deadline is None else deadline - time.time() 5601 try: 5602 plumbing_response = self.stub.Delete( 5603 req, 5604 metadata=self.parent.get_metadata('Resources.Delete', req), 5605 timeout=t) 5606 except Exception as e: 5607 if self.parent.shouldRetry(tries, e, deadline): 5608 tries += 1 5609 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5610 continue 5611 raise plumbing.convert_error_to_porcelain(e) from e 5612 break 5613 5614 resp = models.ResourceDeleteResponse() 5615 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5616 plumbing_response.meta) 5617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5618 plumbing_response.rate_limit) 5619 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
5621 def list(self, filter, *args, timeout=None): 5622 ''' 5623 List gets a list of Resources matching a given set of criteria. 5624 ''' 5625 deadline = None if timeout is None else time.time() + timeout 5626 req = ResourceListRequest() 5627 req.meta.CopyFrom(ListRequestMetadata()) 5628 if self.parent.page_limit > 0: 5629 req.meta.limit = self.parent.page_limit 5630 if self.parent.snapshot_datetime is not None: 5631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5632 5633 req.filter = plumbing.quote_filter_args(filter, *args) 5634 5635 def generator(svc, req): 5636 tries = 0 5637 while True: 5638 t = None if deadline is None else deadline - time.time() 5639 try: 5640 plumbing_response = svc.stub.List( 5641 req, 5642 metadata=svc.parent.get_metadata( 5643 'Resources.List', req), 5644 timeout=t) 5645 except Exception as e: 5646 if self.parent.shouldRetry(tries, e, deadline): 5647 tries += 1 5648 time.sleep( 5649 self.parent.exponentialBackoff(tries, deadline)) 5650 continue 5651 raise plumbing.convert_error_to_porcelain(e) from e 5652 tries = 0 5653 for plumbing_item in plumbing_response.resources: 5654 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5655 if plumbing_response.meta.next_cursor == '': 5656 break 5657 req.meta.cursor = plumbing_response.meta.next_cursor 5658 5659 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
5661 def healthcheck(self, id, timeout=None): 5662 ''' 5663 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5664 large network of Nodes. The call will return immediately, and the updated health of the 5665 Resource can be retrieved via Get or List. 5666 ''' 5667 deadline = None if timeout is None else time.time() + timeout 5668 req = ResourceHealthcheckRequest() 5669 5670 req.id = (id) 5671 tries = 0 5672 plumbing_response = None 5673 while True: 5674 t = None if deadline is None else deadline - time.time() 5675 try: 5676 plumbing_response = self.stub.Healthcheck( 5677 req, 5678 metadata=self.parent.get_metadata('Resources.Healthcheck', 5679 req), 5680 timeout=t) 5681 except Exception as e: 5682 if self.parent.shouldRetry(tries, e, deadline): 5683 tries += 1 5684 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5685 continue 5686 raise plumbing.convert_error_to_porcelain(e) from e 5687 break 5688 5689 resp = models.ResourceHealthcheckResponse() 5690 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5691 plumbing_response.meta) 5692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5693 plumbing_response.rate_limit) 5694 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:
5697class SnapshotResources: 5698 ''' 5699 SnapshotResources exposes the read only methods of the Resources 5700 service for historical queries. 5701 ''' 5702 def __init__(self, resources): 5703 self.resources = resources 5704 5705 def get(self, id, timeout=None): 5706 ''' 5707 Get reads one Resource by ID. 5708 ''' 5709 return self.resources.get(id, timeout=timeout) 5710 5711 def list(self, filter, *args, timeout=None): 5712 ''' 5713 List gets a list of Resources matching a given set of criteria. 5714 ''' 5715 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)
5705 def get(self, id, timeout=None): 5706 ''' 5707 Get reads one Resource by ID. 5708 ''' 5709 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
5711 def list(self, filter, *args, timeout=None): 5712 ''' 5713 List gets a list of Resources matching a given set of criteria. 5714 ''' 5715 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
5718class ResourcesHistory: 5719 ''' 5720 ResourcesHistory records all changes to the state of a Resource. 5721 See `strongdm.models.ResourceHistory`. 5722 ''' 5723 def __init__(self, channel, client): 5724 self.parent = client 5725 self.stub = ResourcesHistoryStub(channel) 5726 5727 def list(self, filter, *args, timeout=None): 5728 ''' 5729 List gets a list of ResourceHistory records matching a given set of criteria. 5730 ''' 5731 deadline = None if timeout is None else time.time() + timeout 5732 req = ResourceHistoryListRequest() 5733 req.meta.CopyFrom(ListRequestMetadata()) 5734 if self.parent.page_limit > 0: 5735 req.meta.limit = self.parent.page_limit 5736 if self.parent.snapshot_datetime is not None: 5737 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5738 5739 req.filter = plumbing.quote_filter_args(filter, *args) 5740 5741 def generator(svc, req): 5742 tries = 0 5743 while True: 5744 t = None if deadline is None else deadline - time.time() 5745 try: 5746 plumbing_response = svc.stub.List( 5747 req, 5748 metadata=svc.parent.get_metadata( 5749 'ResourcesHistory.List', req), 5750 timeout=t) 5751 except Exception as e: 5752 if self.parent.shouldRetry(tries, e, deadline): 5753 tries += 1 5754 time.sleep( 5755 self.parent.exponentialBackoff(tries, deadline)) 5756 continue 5757 raise plumbing.convert_error_to_porcelain(e) from e 5758 tries = 0 5759 for plumbing_item in plumbing_response.history: 5760 yield plumbing.convert_resource_history_to_porcelain( 5761 plumbing_item) 5762 if plumbing_response.meta.next_cursor == '': 5763 break 5764 req.meta.cursor = plumbing_response.meta.next_cursor 5765 5766 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)
5727 def list(self, filter, *args, timeout=None): 5728 ''' 5729 List gets a list of ResourceHistory records matching a given set of criteria. 5730 ''' 5731 deadline = None if timeout is None else time.time() + timeout 5732 req = ResourceHistoryListRequest() 5733 req.meta.CopyFrom(ListRequestMetadata()) 5734 if self.parent.page_limit > 0: 5735 req.meta.limit = self.parent.page_limit 5736 if self.parent.snapshot_datetime is not None: 5737 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5738 5739 req.filter = plumbing.quote_filter_args(filter, *args) 5740 5741 def generator(svc, req): 5742 tries = 0 5743 while True: 5744 t = None if deadline is None else deadline - time.time() 5745 try: 5746 plumbing_response = svc.stub.List( 5747 req, 5748 metadata=svc.parent.get_metadata( 5749 'ResourcesHistory.List', req), 5750 timeout=t) 5751 except Exception as e: 5752 if self.parent.shouldRetry(tries, e, deadline): 5753 tries += 1 5754 time.sleep( 5755 self.parent.exponentialBackoff(tries, deadline)) 5756 continue 5757 raise plumbing.convert_error_to_porcelain(e) from e 5758 tries = 0 5759 for plumbing_item in plumbing_response.history: 5760 yield plumbing.convert_resource_history_to_porcelain( 5761 plumbing_item) 5762 if plumbing_response.meta.next_cursor == '': 5763 break 5764 req.meta.cursor = plumbing_response.meta.next_cursor 5765 5766 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
5769class RoleResources: 5770 ''' 5771 RoleResources enumerates the resources to which roles have access. 5772 The RoleResources service is read-only. 5773 See `strongdm.models.RoleResource`. 5774 ''' 5775 def __init__(self, channel, client): 5776 self.parent = client 5777 self.stub = RoleResourcesStub(channel) 5778 5779 def list(self, filter, *args, timeout=None): 5780 ''' 5781 List gets a list of RoleResource records matching a given set of criteria. 5782 ''' 5783 deadline = None if timeout is None else time.time() + timeout 5784 req = RoleResourceListRequest() 5785 req.meta.CopyFrom(ListRequestMetadata()) 5786 if self.parent.page_limit > 0: 5787 req.meta.limit = self.parent.page_limit 5788 if self.parent.snapshot_datetime is not None: 5789 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5790 5791 req.filter = plumbing.quote_filter_args(filter, *args) 5792 5793 def generator(svc, req): 5794 tries = 0 5795 while True: 5796 t = None if deadline is None else deadline - time.time() 5797 try: 5798 plumbing_response = svc.stub.List( 5799 req, 5800 metadata=svc.parent.get_metadata( 5801 'RoleResources.List', req), 5802 timeout=t) 5803 except Exception as e: 5804 if self.parent.shouldRetry(tries, e, deadline): 5805 tries += 1 5806 time.sleep( 5807 self.parent.exponentialBackoff(tries, deadline)) 5808 continue 5809 raise plumbing.convert_error_to_porcelain(e) from e 5810 tries = 0 5811 for plumbing_item in plumbing_response.role_resources: 5812 yield plumbing.convert_role_resource_to_porcelain( 5813 plumbing_item) 5814 if plumbing_response.meta.next_cursor == '': 5815 break 5816 req.meta.cursor = plumbing_response.meta.next_cursor 5817 5818 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)
5779 def list(self, filter, *args, timeout=None): 5780 ''' 5781 List gets a list of RoleResource records matching a given set of criteria. 5782 ''' 5783 deadline = None if timeout is None else time.time() + timeout 5784 req = RoleResourceListRequest() 5785 req.meta.CopyFrom(ListRequestMetadata()) 5786 if self.parent.page_limit > 0: 5787 req.meta.limit = self.parent.page_limit 5788 if self.parent.snapshot_datetime is not None: 5789 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5790 5791 req.filter = plumbing.quote_filter_args(filter, *args) 5792 5793 def generator(svc, req): 5794 tries = 0 5795 while True: 5796 t = None if deadline is None else deadline - time.time() 5797 try: 5798 plumbing_response = svc.stub.List( 5799 req, 5800 metadata=svc.parent.get_metadata( 5801 'RoleResources.List', req), 5802 timeout=t) 5803 except Exception as e: 5804 if self.parent.shouldRetry(tries, e, deadline): 5805 tries += 1 5806 time.sleep( 5807 self.parent.exponentialBackoff(tries, deadline)) 5808 continue 5809 raise plumbing.convert_error_to_porcelain(e) from e 5810 tries = 0 5811 for plumbing_item in plumbing_response.role_resources: 5812 yield plumbing.convert_role_resource_to_porcelain( 5813 plumbing_item) 5814 if plumbing_response.meta.next_cursor == '': 5815 break 5816 req.meta.cursor = plumbing_response.meta.next_cursor 5817 5818 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
5821class SnapshotRoleResources: 5822 ''' 5823 SnapshotRoleResources exposes the read only methods of the RoleResources 5824 service for historical queries. 5825 ''' 5826 def __init__(self, role_resources): 5827 self.role_resources = role_resources 5828 5829 def list(self, filter, *args, timeout=None): 5830 ''' 5831 List gets a list of RoleResource records matching a given set of criteria. 5832 ''' 5833 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)
5829 def list(self, filter, *args, timeout=None): 5830 ''' 5831 List gets a list of RoleResource records matching a given set of criteria. 5832 ''' 5833 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
5836class RoleResourcesHistory: 5837 ''' 5838 RoleResourcesHistory records all changes to the state of a RoleResource. 5839 See `strongdm.models.RoleResourceHistory`. 5840 ''' 5841 def __init__(self, channel, client): 5842 self.parent = client 5843 self.stub = RoleResourcesHistoryStub(channel) 5844 5845 def list(self, filter, *args, timeout=None): 5846 ''' 5847 List gets a list of RoleResourceHistory records matching a given set of criteria. 5848 ''' 5849 deadline = None if timeout is None else time.time() + timeout 5850 req = RoleResourceHistoryListRequest() 5851 req.meta.CopyFrom(ListRequestMetadata()) 5852 if self.parent.page_limit > 0: 5853 req.meta.limit = self.parent.page_limit 5854 if self.parent.snapshot_datetime is not None: 5855 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5856 5857 req.filter = plumbing.quote_filter_args(filter, *args) 5858 5859 def generator(svc, req): 5860 tries = 0 5861 while True: 5862 t = None if deadline is None else deadline - time.time() 5863 try: 5864 plumbing_response = svc.stub.List( 5865 req, 5866 metadata=svc.parent.get_metadata( 5867 'RoleResourcesHistory.List', req), 5868 timeout=t) 5869 except Exception as e: 5870 if self.parent.shouldRetry(tries, e, deadline): 5871 tries += 1 5872 time.sleep( 5873 self.parent.exponentialBackoff(tries, deadline)) 5874 continue 5875 raise plumbing.convert_error_to_porcelain(e) from e 5876 tries = 0 5877 for plumbing_item in plumbing_response.history: 5878 yield plumbing.convert_role_resource_history_to_porcelain( 5879 plumbing_item) 5880 if plumbing_response.meta.next_cursor == '': 5881 break 5882 req.meta.cursor = plumbing_response.meta.next_cursor 5883 5884 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)
5845 def list(self, filter, *args, timeout=None): 5846 ''' 5847 List gets a list of RoleResourceHistory records matching a given set of criteria. 5848 ''' 5849 deadline = None if timeout is None else time.time() + timeout 5850 req = RoleResourceHistoryListRequest() 5851 req.meta.CopyFrom(ListRequestMetadata()) 5852 if self.parent.page_limit > 0: 5853 req.meta.limit = self.parent.page_limit 5854 if self.parent.snapshot_datetime is not None: 5855 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5856 5857 req.filter = plumbing.quote_filter_args(filter, *args) 5858 5859 def generator(svc, req): 5860 tries = 0 5861 while True: 5862 t = None if deadline is None else deadline - time.time() 5863 try: 5864 plumbing_response = svc.stub.List( 5865 req, 5866 metadata=svc.parent.get_metadata( 5867 'RoleResourcesHistory.List', req), 5868 timeout=t) 5869 except Exception as e: 5870 if self.parent.shouldRetry(tries, e, deadline): 5871 tries += 1 5872 time.sleep( 5873 self.parent.exponentialBackoff(tries, deadline)) 5874 continue 5875 raise plumbing.convert_error_to_porcelain(e) from e 5876 tries = 0 5877 for plumbing_item in plumbing_response.history: 5878 yield plumbing.convert_role_resource_history_to_porcelain( 5879 plumbing_item) 5880 if plumbing_response.meta.next_cursor == '': 5881 break 5882 req.meta.cursor = plumbing_response.meta.next_cursor 5883 5884 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
5887class RolesHistory: 5888 ''' 5889 RolesHistory records all changes to the state of a Role. 5890 See `strongdm.models.RoleHistory`. 5891 ''' 5892 def __init__(self, channel, client): 5893 self.parent = client 5894 self.stub = RolesHistoryStub(channel) 5895 5896 def list(self, filter, *args, timeout=None): 5897 ''' 5898 List gets a list of RoleHistory records matching a given set of criteria. 5899 ''' 5900 deadline = None if timeout is None else time.time() + timeout 5901 req = RoleHistoryListRequest() 5902 req.meta.CopyFrom(ListRequestMetadata()) 5903 if self.parent.page_limit > 0: 5904 req.meta.limit = self.parent.page_limit 5905 if self.parent.snapshot_datetime is not None: 5906 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5907 5908 req.filter = plumbing.quote_filter_args(filter, *args) 5909 5910 def generator(svc, req): 5911 tries = 0 5912 while True: 5913 t = None if deadline is None else deadline - time.time() 5914 try: 5915 plumbing_response = svc.stub.List( 5916 req, 5917 metadata=svc.parent.get_metadata( 5918 'RolesHistory.List', req), 5919 timeout=t) 5920 except Exception as e: 5921 if self.parent.shouldRetry(tries, e, deadline): 5922 tries += 1 5923 time.sleep( 5924 self.parent.exponentialBackoff(tries, deadline)) 5925 continue 5926 raise plumbing.convert_error_to_porcelain(e) from e 5927 tries = 0 5928 for plumbing_item in plumbing_response.history: 5929 yield plumbing.convert_role_history_to_porcelain( 5930 plumbing_item) 5931 if plumbing_response.meta.next_cursor == '': 5932 break 5933 req.meta.cursor = plumbing_response.meta.next_cursor 5934 5935 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)
5896 def list(self, filter, *args, timeout=None): 5897 ''' 5898 List gets a list of RoleHistory records matching a given set of criteria. 5899 ''' 5900 deadline = None if timeout is None else time.time() + timeout 5901 req = RoleHistoryListRequest() 5902 req.meta.CopyFrom(ListRequestMetadata()) 5903 if self.parent.page_limit > 0: 5904 req.meta.limit = self.parent.page_limit 5905 if self.parent.snapshot_datetime is not None: 5906 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5907 5908 req.filter = plumbing.quote_filter_args(filter, *args) 5909 5910 def generator(svc, req): 5911 tries = 0 5912 while True: 5913 t = None if deadline is None else deadline - time.time() 5914 try: 5915 plumbing_response = svc.stub.List( 5916 req, 5917 metadata=svc.parent.get_metadata( 5918 'RolesHistory.List', req), 5919 timeout=t) 5920 except Exception as e: 5921 if self.parent.shouldRetry(tries, e, deadline): 5922 tries += 1 5923 time.sleep( 5924 self.parent.exponentialBackoff(tries, deadline)) 5925 continue 5926 raise plumbing.convert_error_to_porcelain(e) from e 5927 tries = 0 5928 for plumbing_item in plumbing_response.history: 5929 yield plumbing.convert_role_history_to_porcelain( 5930 plumbing_item) 5931 if plumbing_response.meta.next_cursor == '': 5932 break 5933 req.meta.cursor = plumbing_response.meta.next_cursor 5934 5935 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
5938class SecretStores: 5939 ''' 5940 SecretStores are servers where resource secrets (passwords, keys) are stored. 5941 See: 5942 `strongdm.models.ActiveDirectoryStore` 5943 `strongdm.models.AWSStore` 5944 `strongdm.models.AWSCertX509Store` 5945 `strongdm.models.AzureStore` 5946 `strongdm.models.CyberarkConjurStore` 5947 `strongdm.models.CyberarkPAMStore` 5948 `strongdm.models.CyberarkPAMExperimentalStore` 5949 `strongdm.models.DelineaStore` 5950 `strongdm.models.GCPStore` 5951 `strongdm.models.GCPCertX509Store` 5952 `strongdm.models.KeyfactorSSHStore` 5953 `strongdm.models.KeyfactorX509Store` 5954 `strongdm.models.VaultAppRoleStore` 5955 `strongdm.models.VaultAppRoleCertSSHStore` 5956 `strongdm.models.VaultAppRoleCertX509Store` 5957 `strongdm.models.VaultAWSEC2Store` 5958 `strongdm.models.VaultAWSIAMStore` 5959 `strongdm.models.VaultTLSStore` 5960 `strongdm.models.VaultTLSCertSSHStore` 5961 `strongdm.models.VaultTLSCertX509Store` 5962 `strongdm.models.VaultTokenStore` 5963 `strongdm.models.VaultTokenCertSSHStore` 5964 `strongdm.models.VaultTokenCertX509Store` 5965 ''' 5966 def __init__(self, channel, client): 5967 self.parent = client 5968 self.stub = SecretStoresStub(channel) 5969 5970 def create(self, secret_store, timeout=None): 5971 deadline = None if timeout is None else time.time() + timeout 5972 req = SecretStoreCreateRequest() 5973 5974 if secret_store is not None: 5975 req.secret_store.CopyFrom( 5976 plumbing.convert_secret_store_to_plumbing(secret_store)) 5977 tries = 0 5978 plumbing_response = None 5979 while True: 5980 t = None if deadline is None else deadline - time.time() 5981 try: 5982 plumbing_response = self.stub.Create( 5983 req, 5984 metadata=self.parent.get_metadata('SecretStores.Create', 5985 req), 5986 timeout=t) 5987 except Exception as e: 5988 if self.parent.shouldRetry(tries, e, deadline): 5989 tries += 1 5990 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5991 continue 5992 raise plumbing.convert_error_to_porcelain(e) from e 5993 break 5994 5995 resp = models.SecretStoreCreateResponse() 5996 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5997 plumbing_response.meta) 5998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5999 plumbing_response.rate_limit) 6000 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6001 plumbing_response.secret_store) 6002 return resp 6003 6004 def get(self, id, timeout=None): 6005 ''' 6006 Get reads one SecretStore by ID. 6007 ''' 6008 deadline = None if timeout is None else time.time() + timeout 6009 req = SecretStoreGetRequest() 6010 if self.parent.snapshot_datetime is not None: 6011 req.meta.CopyFrom(GetRequestMetadata()) 6012 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6013 6014 req.id = (id) 6015 tries = 0 6016 plumbing_response = None 6017 while True: 6018 t = None if deadline is None else deadline - time.time() 6019 try: 6020 plumbing_response = self.stub.Get( 6021 req, 6022 metadata=self.parent.get_metadata('SecretStores.Get', req), 6023 timeout=t) 6024 except Exception as e: 6025 if self.parent.shouldRetry(tries, e, deadline): 6026 tries += 1 6027 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6028 continue 6029 raise plumbing.convert_error_to_porcelain(e) from e 6030 break 6031 6032 resp = models.SecretStoreGetResponse() 6033 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6034 plumbing_response.meta) 6035 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6036 plumbing_response.rate_limit) 6037 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6038 plumbing_response.secret_store) 6039 return resp 6040 6041 def update(self, secret_store, timeout=None): 6042 ''' 6043 Update replaces all the fields of a SecretStore by ID. 6044 ''' 6045 deadline = None if timeout is None else time.time() + timeout 6046 req = SecretStoreUpdateRequest() 6047 6048 if secret_store is not None: 6049 req.secret_store.CopyFrom( 6050 plumbing.convert_secret_store_to_plumbing(secret_store)) 6051 tries = 0 6052 plumbing_response = None 6053 while True: 6054 t = None if deadline is None else deadline - time.time() 6055 try: 6056 plumbing_response = self.stub.Update( 6057 req, 6058 metadata=self.parent.get_metadata('SecretStores.Update', 6059 req), 6060 timeout=t) 6061 except Exception as e: 6062 if self.parent.shouldRetry(tries, e, deadline): 6063 tries += 1 6064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6065 continue 6066 raise plumbing.convert_error_to_porcelain(e) from e 6067 break 6068 6069 resp = models.SecretStoreUpdateResponse() 6070 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6071 plumbing_response.meta) 6072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6073 plumbing_response.rate_limit) 6074 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6075 plumbing_response.secret_store) 6076 return resp 6077 6078 def delete(self, id, timeout=None): 6079 ''' 6080 Delete removes a SecretStore by ID. 6081 ''' 6082 deadline = None if timeout is None else time.time() + timeout 6083 req = SecretStoreDeleteRequest() 6084 6085 req.id = (id) 6086 tries = 0 6087 plumbing_response = None 6088 while True: 6089 t = None if deadline is None else deadline - time.time() 6090 try: 6091 plumbing_response = self.stub.Delete( 6092 req, 6093 metadata=self.parent.get_metadata('SecretStores.Delete', 6094 req), 6095 timeout=t) 6096 except Exception as e: 6097 if self.parent.shouldRetry(tries, e, deadline): 6098 tries += 1 6099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6100 continue 6101 raise plumbing.convert_error_to_porcelain(e) from e 6102 break 6103 6104 resp = models.SecretStoreDeleteResponse() 6105 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6106 plumbing_response.meta) 6107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6108 plumbing_response.rate_limit) 6109 return resp 6110 6111 def list(self, filter, *args, timeout=None): 6112 ''' 6113 List gets a list of SecretStores matching a given set of criteria. 6114 ''' 6115 deadline = None if timeout is None else time.time() + timeout 6116 req = SecretStoreListRequest() 6117 req.meta.CopyFrom(ListRequestMetadata()) 6118 if self.parent.page_limit > 0: 6119 req.meta.limit = self.parent.page_limit 6120 if self.parent.snapshot_datetime is not None: 6121 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6122 6123 req.filter = plumbing.quote_filter_args(filter, *args) 6124 6125 def generator(svc, req): 6126 tries = 0 6127 while True: 6128 t = None if deadline is None else deadline - time.time() 6129 try: 6130 plumbing_response = svc.stub.List( 6131 req, 6132 metadata=svc.parent.get_metadata( 6133 'SecretStores.List', req), 6134 timeout=t) 6135 except Exception as e: 6136 if self.parent.shouldRetry(tries, e, deadline): 6137 tries += 1 6138 time.sleep( 6139 self.parent.exponentialBackoff(tries, deadline)) 6140 continue 6141 raise plumbing.convert_error_to_porcelain(e) from e 6142 tries = 0 6143 for plumbing_item in plumbing_response.secret_stores: 6144 yield plumbing.convert_secret_store_to_porcelain( 6145 plumbing_item) 6146 if plumbing_response.meta.next_cursor == '': 6147 break 6148 req.meta.cursor = plumbing_response.meta.next_cursor 6149 6150 return generator(self, req)
SecretStores are servers where resource secrets (passwords, keys) are stored.
See:
strongdm.models.ActiveDirectoryStore
strongdm.models.AWSStore
strongdm.models.AWSCertX509Store
strongdm.models.AzureStore
strongdm.models.CyberarkConjurStore
strongdm.models.CyberarkPAMStore
strongdm.models.CyberarkPAMExperimentalStore
strongdm.models.DelineaStore
strongdm.models.GCPStore
strongdm.models.GCPCertX509Store
strongdm.models.KeyfactorSSHStore
strongdm.models.KeyfactorX509Store
strongdm.models.VaultAppRoleStore
strongdm.models.VaultAppRoleCertSSHStore
strongdm.models.VaultAppRoleCertX509Store
strongdm.models.VaultAWSEC2Store
strongdm.models.VaultAWSIAMStore
strongdm.models.VaultTLSStore
strongdm.models.VaultTLSCertSSHStore
strongdm.models.VaultTLSCertX509Store
strongdm.models.VaultTokenStore
strongdm.models.VaultTokenCertSSHStore
strongdm.models.VaultTokenCertX509Store
def
create(self, secret_store, timeout=None)
5970 def create(self, secret_store, timeout=None): 5971 deadline = None if timeout is None else time.time() + timeout 5972 req = SecretStoreCreateRequest() 5973 5974 if secret_store is not None: 5975 req.secret_store.CopyFrom( 5976 plumbing.convert_secret_store_to_plumbing(secret_store)) 5977 tries = 0 5978 plumbing_response = None 5979 while True: 5980 t = None if deadline is None else deadline - time.time() 5981 try: 5982 plumbing_response = self.stub.Create( 5983 req, 5984 metadata=self.parent.get_metadata('SecretStores.Create', 5985 req), 5986 timeout=t) 5987 except Exception as e: 5988 if self.parent.shouldRetry(tries, e, deadline): 5989 tries += 1 5990 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5991 continue 5992 raise plumbing.convert_error_to_porcelain(e) from e 5993 break 5994 5995 resp = models.SecretStoreCreateResponse() 5996 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5997 plumbing_response.meta) 5998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5999 plumbing_response.rate_limit) 6000 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6001 plumbing_response.secret_store) 6002 return resp
def
get(self, id, timeout=None)
6004 def get(self, id, timeout=None): 6005 ''' 6006 Get reads one SecretStore by ID. 6007 ''' 6008 deadline = None if timeout is None else time.time() + timeout 6009 req = SecretStoreGetRequest() 6010 if self.parent.snapshot_datetime is not None: 6011 req.meta.CopyFrom(GetRequestMetadata()) 6012 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6013 6014 req.id = (id) 6015 tries = 0 6016 plumbing_response = None 6017 while True: 6018 t = None if deadline is None else deadline - time.time() 6019 try: 6020 plumbing_response = self.stub.Get( 6021 req, 6022 metadata=self.parent.get_metadata('SecretStores.Get', req), 6023 timeout=t) 6024 except Exception as e: 6025 if self.parent.shouldRetry(tries, e, deadline): 6026 tries += 1 6027 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6028 continue 6029 raise plumbing.convert_error_to_porcelain(e) from e 6030 break 6031 6032 resp = models.SecretStoreGetResponse() 6033 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6034 plumbing_response.meta) 6035 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6036 plumbing_response.rate_limit) 6037 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6038 plumbing_response.secret_store) 6039 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
6041 def update(self, secret_store, timeout=None): 6042 ''' 6043 Update replaces all the fields of a SecretStore by ID. 6044 ''' 6045 deadline = None if timeout is None else time.time() + timeout 6046 req = SecretStoreUpdateRequest() 6047 6048 if secret_store is not None: 6049 req.secret_store.CopyFrom( 6050 plumbing.convert_secret_store_to_plumbing(secret_store)) 6051 tries = 0 6052 plumbing_response = None 6053 while True: 6054 t = None if deadline is None else deadline - time.time() 6055 try: 6056 plumbing_response = self.stub.Update( 6057 req, 6058 metadata=self.parent.get_metadata('SecretStores.Update', 6059 req), 6060 timeout=t) 6061 except Exception as e: 6062 if self.parent.shouldRetry(tries, e, deadline): 6063 tries += 1 6064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6065 continue 6066 raise plumbing.convert_error_to_porcelain(e) from e 6067 break 6068 6069 resp = models.SecretStoreUpdateResponse() 6070 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6071 plumbing_response.meta) 6072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6073 plumbing_response.rate_limit) 6074 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6075 plumbing_response.secret_store) 6076 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
6078 def delete(self, id, timeout=None): 6079 ''' 6080 Delete removes a SecretStore by ID. 6081 ''' 6082 deadline = None if timeout is None else time.time() + timeout 6083 req = SecretStoreDeleteRequest() 6084 6085 req.id = (id) 6086 tries = 0 6087 plumbing_response = None 6088 while True: 6089 t = None if deadline is None else deadline - time.time() 6090 try: 6091 plumbing_response = self.stub.Delete( 6092 req, 6093 metadata=self.parent.get_metadata('SecretStores.Delete', 6094 req), 6095 timeout=t) 6096 except Exception as e: 6097 if self.parent.shouldRetry(tries, e, deadline): 6098 tries += 1 6099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6100 continue 6101 raise plumbing.convert_error_to_porcelain(e) from e 6102 break 6103 6104 resp = models.SecretStoreDeleteResponse() 6105 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6106 plumbing_response.meta) 6107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6108 plumbing_response.rate_limit) 6109 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6111 def list(self, filter, *args, timeout=None): 6112 ''' 6113 List gets a list of SecretStores matching a given set of criteria. 6114 ''' 6115 deadline = None if timeout is None else time.time() + timeout 6116 req = SecretStoreListRequest() 6117 req.meta.CopyFrom(ListRequestMetadata()) 6118 if self.parent.page_limit > 0: 6119 req.meta.limit = self.parent.page_limit 6120 if self.parent.snapshot_datetime is not None: 6121 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6122 6123 req.filter = plumbing.quote_filter_args(filter, *args) 6124 6125 def generator(svc, req): 6126 tries = 0 6127 while True: 6128 t = None if deadline is None else deadline - time.time() 6129 try: 6130 plumbing_response = svc.stub.List( 6131 req, 6132 metadata=svc.parent.get_metadata( 6133 'SecretStores.List', req), 6134 timeout=t) 6135 except Exception as e: 6136 if self.parent.shouldRetry(tries, e, deadline): 6137 tries += 1 6138 time.sleep( 6139 self.parent.exponentialBackoff(tries, deadline)) 6140 continue 6141 raise plumbing.convert_error_to_porcelain(e) from e 6142 tries = 0 6143 for plumbing_item in plumbing_response.secret_stores: 6144 yield plumbing.convert_secret_store_to_porcelain( 6145 plumbing_item) 6146 if plumbing_response.meta.next_cursor == '': 6147 break 6148 req.meta.cursor = plumbing_response.meta.next_cursor 6149 6150 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
6153class SnapshotSecretStores: 6154 ''' 6155 SnapshotSecretStores exposes the read only methods of the SecretStores 6156 service for historical queries. 6157 ''' 6158 def __init__(self, secret_stores): 6159 self.secret_stores = secret_stores 6160 6161 def get(self, id, timeout=None): 6162 ''' 6163 Get reads one SecretStore by ID. 6164 ''' 6165 return self.secret_stores.get(id, timeout=timeout) 6166 6167 def list(self, filter, *args, timeout=None): 6168 ''' 6169 List gets a list of SecretStores matching a given set of criteria. 6170 ''' 6171 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)
6161 def get(self, id, timeout=None): 6162 ''' 6163 Get reads one SecretStore by ID. 6164 ''' 6165 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6167 def list(self, filter, *args, timeout=None): 6168 ''' 6169 List gets a list of SecretStores matching a given set of criteria. 6170 ''' 6171 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
6174class SecretEngines: 6175 ''' 6176 6177 See: 6178 `strongdm.models.ActiveDirectoryEngine` 6179 `strongdm.models.KeyValueEngine` 6180 ''' 6181 def __init__(self, channel, client): 6182 self.parent = client 6183 self.stub = SecretEnginesStub(channel) 6184 6185 def list(self, filter, *args, timeout=None): 6186 ''' 6187 List returns a list of Secret Engines 6188 ''' 6189 deadline = None if timeout is None else time.time() + timeout 6190 req = SecretEngineListRequest() 6191 req.meta.CopyFrom(ListRequestMetadata()) 6192 if self.parent.page_limit > 0: 6193 req.meta.limit = self.parent.page_limit 6194 if self.parent.snapshot_datetime is not None: 6195 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6196 6197 req.filter = plumbing.quote_filter_args(filter, *args) 6198 6199 def generator(svc, req): 6200 tries = 0 6201 while True: 6202 t = None if deadline is None else deadline - time.time() 6203 try: 6204 plumbing_response = svc.stub.List( 6205 req, 6206 metadata=svc.parent.get_metadata( 6207 'SecretEngines.List', req), 6208 timeout=t) 6209 except Exception as e: 6210 if self.parent.shouldRetry(tries, e, deadline): 6211 tries += 1 6212 time.sleep( 6213 self.parent.exponentialBackoff(tries, deadline)) 6214 continue 6215 raise plumbing.convert_error_to_porcelain(e) from e 6216 tries = 0 6217 for plumbing_item in plumbing_response.secret_engines: 6218 yield plumbing.convert_secret_engine_to_porcelain( 6219 plumbing_item) 6220 if plumbing_response.meta.next_cursor == '': 6221 break 6222 req.meta.cursor = plumbing_response.meta.next_cursor 6223 6224 return generator(self, req) 6225 6226 def get(self, id, timeout=None): 6227 ''' 6228 Get returns a secret engine details 6229 ''' 6230 deadline = None if timeout is None else time.time() + timeout 6231 req = SecretEngineGetRequest() 6232 if self.parent.snapshot_datetime is not None: 6233 req.meta.CopyFrom(GetRequestMetadata()) 6234 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6235 6236 req.id = (id) 6237 tries = 0 6238 plumbing_response = None 6239 while True: 6240 t = None if deadline is None else deadline - time.time() 6241 try: 6242 plumbing_response = self.stub.Get( 6243 req, 6244 metadata=self.parent.get_metadata('SecretEngines.Get', 6245 req), 6246 timeout=t) 6247 except Exception as e: 6248 if self.parent.shouldRetry(tries, e, deadline): 6249 tries += 1 6250 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6251 continue 6252 raise plumbing.convert_error_to_porcelain(e) from e 6253 break 6254 6255 resp = models.SecretEngineGetResponse() 6256 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6257 plumbing_response.meta) 6258 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6259 plumbing_response.rate_limit) 6260 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6261 plumbing_response.secret_engine) 6262 return resp 6263 6264 def create(self, secret_engine, timeout=None): 6265 ''' 6266 Create creates a secret engine 6267 ''' 6268 deadline = None if timeout is None else time.time() + timeout 6269 req = SecretEngineCreateRequest() 6270 6271 if secret_engine is not None: 6272 req.secret_engine.CopyFrom( 6273 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6274 tries = 0 6275 plumbing_response = None 6276 while True: 6277 t = None if deadline is None else deadline - time.time() 6278 try: 6279 plumbing_response = self.stub.Create( 6280 req, 6281 metadata=self.parent.get_metadata('SecretEngines.Create', 6282 req), 6283 timeout=t) 6284 except Exception as e: 6285 if self.parent.shouldRetry(tries, e, deadline): 6286 tries += 1 6287 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6288 continue 6289 raise plumbing.convert_error_to_porcelain(e) from e 6290 break 6291 6292 resp = models.SecretEngineCreateResponse() 6293 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6294 plumbing_response.meta) 6295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6296 plumbing_response.rate_limit) 6297 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6298 plumbing_response.secret_engine) 6299 return resp 6300 6301 def update(self, secret_engine, timeout=None): 6302 ''' 6303 Update updates a secret engine 6304 ''' 6305 deadline = None if timeout is None else time.time() + timeout 6306 req = SecretEngineUpdateRequest() 6307 6308 if secret_engine is not None: 6309 req.secret_engine.CopyFrom( 6310 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6311 tries = 0 6312 plumbing_response = None 6313 while True: 6314 t = None if deadline is None else deadline - time.time() 6315 try: 6316 plumbing_response = self.stub.Update( 6317 req, 6318 metadata=self.parent.get_metadata('SecretEngines.Update', 6319 req), 6320 timeout=t) 6321 except Exception as e: 6322 if self.parent.shouldRetry(tries, e, deadline): 6323 tries += 1 6324 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6325 continue 6326 raise plumbing.convert_error_to_porcelain(e) from e 6327 break 6328 6329 resp = models.SecretEngineUpdateResponse() 6330 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6331 plumbing_response.meta) 6332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6333 plumbing_response.rate_limit) 6334 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6335 plumbing_response.secret_engine) 6336 return resp 6337 6338 def delete(self, id, timeout=None): 6339 ''' 6340 Delete deletes a secret engine 6341 ''' 6342 deadline = None if timeout is None else time.time() + timeout 6343 req = SecretEngineDeleteRequest() 6344 6345 req.id = (id) 6346 tries = 0 6347 plumbing_response = None 6348 while True: 6349 t = None if deadline is None else deadline - time.time() 6350 try: 6351 plumbing_response = self.stub.Delete( 6352 req, 6353 metadata=self.parent.get_metadata('SecretEngines.Delete', 6354 req), 6355 timeout=t) 6356 except Exception as e: 6357 if self.parent.shouldRetry(tries, e, deadline): 6358 tries += 1 6359 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6360 continue 6361 raise plumbing.convert_error_to_porcelain(e) from e 6362 break 6363 6364 resp = models.SecretEngineDeleteResponse() 6365 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6366 plumbing_response.rate_limit) 6367 return resp 6368 6369 def list_secret_stores(self, filter, *args, timeout=None): 6370 ''' 6371 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6372 for Secret Engine 6373 ''' 6374 deadline = None if timeout is None else time.time() + timeout 6375 req = SecretStoreListRequest() 6376 req.meta.CopyFrom(ListRequestMetadata()) 6377 if self.parent.page_limit > 0: 6378 req.meta.limit = self.parent.page_limit 6379 if self.parent.snapshot_datetime is not None: 6380 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6381 6382 req.filter = plumbing.quote_filter_args(filter, *args) 6383 6384 def generator(svc, req): 6385 tries = 0 6386 while True: 6387 t = None if deadline is None else deadline - time.time() 6388 try: 6389 plumbing_response = svc.stub.ListSecretStores( 6390 req, 6391 metadata=svc.parent.get_metadata( 6392 'SecretEngines.ListSecretStores', req), 6393 timeout=t) 6394 except Exception as e: 6395 if self.parent.shouldRetry(tries, e, deadline): 6396 tries += 1 6397 time.sleep( 6398 self.parent.exponentialBackoff(tries, deadline)) 6399 continue 6400 raise plumbing.convert_error_to_porcelain(e) from e 6401 tries = 0 6402 for plumbing_item in plumbing_response.secret_stores: 6403 yield plumbing.convert_secret_store_to_porcelain( 6404 plumbing_item) 6405 if plumbing_response.meta.next_cursor == '': 6406 break 6407 req.meta.cursor = plumbing_response.meta.next_cursor 6408 6409 return generator(self, req) 6410 6411 def generate_keys(self, secret_engine_id, timeout=None): 6412 ''' 6413 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6414 ''' 6415 deadline = None if timeout is None else time.time() + timeout 6416 req = GenerateKeysRequest() 6417 6418 req.secret_engine_id = (secret_engine_id) 6419 tries = 0 6420 plumbing_response = None 6421 while True: 6422 t = None if deadline is None else deadline - time.time() 6423 try: 6424 plumbing_response = self.stub.GenerateKeys( 6425 req, 6426 metadata=self.parent.get_metadata( 6427 'SecretEngines.GenerateKeys', req), 6428 timeout=t) 6429 except Exception as e: 6430 if self.parent.shouldRetry(tries, e, deadline): 6431 tries += 1 6432 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6433 continue 6434 raise plumbing.convert_error_to_porcelain(e) from e 6435 break 6436 6437 resp = models.GenerateKeysResponse() 6438 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6439 plumbing_response.rate_limit) 6440 return resp 6441 6442 def healthcheck(self, secret_engine_id, timeout=None): 6443 ''' 6444 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6445 ''' 6446 deadline = None if timeout is None else time.time() + timeout 6447 req = HealthcheckRequest() 6448 6449 req.secret_engine_id = (secret_engine_id) 6450 tries = 0 6451 plumbing_response = None 6452 while True: 6453 t = None if deadline is None else deadline - time.time() 6454 try: 6455 plumbing_response = self.stub.Healthcheck( 6456 req, 6457 metadata=self.parent.get_metadata( 6458 'SecretEngines.Healthcheck', req), 6459 timeout=t) 6460 except Exception as e: 6461 if self.parent.shouldRetry(tries, e, deadline): 6462 tries += 1 6463 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6464 continue 6465 raise plumbing.convert_error_to_porcelain(e) from e 6466 break 6467 6468 resp = models.HealthcheckResponse() 6469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6470 plumbing_response.rate_limit) 6471 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6472 plumbing_response.status) 6473 return resp 6474 6475 def rotate(self, id, password_policy, timeout=None): 6476 ''' 6477 Rotate rotates secret engine's credentials 6478 ''' 6479 deadline = None if timeout is None else time.time() + timeout 6480 req = SecretEngineRotateRequest() 6481 6482 req.id = (id) 6483 if password_policy is not None: 6484 req.password_policy.CopyFrom( 6485 plumbing.convert_secret_engine_password_policy_to_plumbing( 6486 password_policy)) 6487 tries = 0 6488 plumbing_response = None 6489 while True: 6490 t = None if deadline is None else deadline - time.time() 6491 try: 6492 plumbing_response = self.stub.Rotate( 6493 req, 6494 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6495 req), 6496 timeout=t) 6497 except Exception as e: 6498 if self.parent.shouldRetry(tries, e, deadline): 6499 tries += 1 6500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6501 continue 6502 raise plumbing.convert_error_to_porcelain(e) from e 6503 break 6504 6505 resp = models.SecretEngineRotateResponse() 6506 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6507 plumbing_response.rate_limit) 6508 return resp
def
list(self, filter, *args, timeout=None)
6185 def list(self, filter, *args, timeout=None): 6186 ''' 6187 List returns a list of Secret Engines 6188 ''' 6189 deadline = None if timeout is None else time.time() + timeout 6190 req = SecretEngineListRequest() 6191 req.meta.CopyFrom(ListRequestMetadata()) 6192 if self.parent.page_limit > 0: 6193 req.meta.limit = self.parent.page_limit 6194 if self.parent.snapshot_datetime is not None: 6195 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6196 6197 req.filter = plumbing.quote_filter_args(filter, *args) 6198 6199 def generator(svc, req): 6200 tries = 0 6201 while True: 6202 t = None if deadline is None else deadline - time.time() 6203 try: 6204 plumbing_response = svc.stub.List( 6205 req, 6206 metadata=svc.parent.get_metadata( 6207 'SecretEngines.List', req), 6208 timeout=t) 6209 except Exception as e: 6210 if self.parent.shouldRetry(tries, e, deadline): 6211 tries += 1 6212 time.sleep( 6213 self.parent.exponentialBackoff(tries, deadline)) 6214 continue 6215 raise plumbing.convert_error_to_porcelain(e) from e 6216 tries = 0 6217 for plumbing_item in plumbing_response.secret_engines: 6218 yield plumbing.convert_secret_engine_to_porcelain( 6219 plumbing_item) 6220 if plumbing_response.meta.next_cursor == '': 6221 break 6222 req.meta.cursor = plumbing_response.meta.next_cursor 6223 6224 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
6226 def get(self, id, timeout=None): 6227 ''' 6228 Get returns a secret engine details 6229 ''' 6230 deadline = None if timeout is None else time.time() + timeout 6231 req = SecretEngineGetRequest() 6232 if self.parent.snapshot_datetime is not None: 6233 req.meta.CopyFrom(GetRequestMetadata()) 6234 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6235 6236 req.id = (id) 6237 tries = 0 6238 plumbing_response = None 6239 while True: 6240 t = None if deadline is None else deadline - time.time() 6241 try: 6242 plumbing_response = self.stub.Get( 6243 req, 6244 metadata=self.parent.get_metadata('SecretEngines.Get', 6245 req), 6246 timeout=t) 6247 except Exception as e: 6248 if self.parent.shouldRetry(tries, e, deadline): 6249 tries += 1 6250 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6251 continue 6252 raise plumbing.convert_error_to_porcelain(e) from e 6253 break 6254 6255 resp = models.SecretEngineGetResponse() 6256 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6257 plumbing_response.meta) 6258 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6259 plumbing_response.rate_limit) 6260 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6261 plumbing_response.secret_engine) 6262 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
6264 def create(self, secret_engine, timeout=None): 6265 ''' 6266 Create creates a secret engine 6267 ''' 6268 deadline = None if timeout is None else time.time() + timeout 6269 req = SecretEngineCreateRequest() 6270 6271 if secret_engine is not None: 6272 req.secret_engine.CopyFrom( 6273 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6274 tries = 0 6275 plumbing_response = None 6276 while True: 6277 t = None if deadline is None else deadline - time.time() 6278 try: 6279 plumbing_response = self.stub.Create( 6280 req, 6281 metadata=self.parent.get_metadata('SecretEngines.Create', 6282 req), 6283 timeout=t) 6284 except Exception as e: 6285 if self.parent.shouldRetry(tries, e, deadline): 6286 tries += 1 6287 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6288 continue 6289 raise plumbing.convert_error_to_porcelain(e) from e 6290 break 6291 6292 resp = models.SecretEngineCreateResponse() 6293 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6294 plumbing_response.meta) 6295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6296 plumbing_response.rate_limit) 6297 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6298 plumbing_response.secret_engine) 6299 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
6301 def update(self, secret_engine, timeout=None): 6302 ''' 6303 Update updates a secret engine 6304 ''' 6305 deadline = None if timeout is None else time.time() + timeout 6306 req = SecretEngineUpdateRequest() 6307 6308 if secret_engine is not None: 6309 req.secret_engine.CopyFrom( 6310 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6311 tries = 0 6312 plumbing_response = None 6313 while True: 6314 t = None if deadline is None else deadline - time.time() 6315 try: 6316 plumbing_response = self.stub.Update( 6317 req, 6318 metadata=self.parent.get_metadata('SecretEngines.Update', 6319 req), 6320 timeout=t) 6321 except Exception as e: 6322 if self.parent.shouldRetry(tries, e, deadline): 6323 tries += 1 6324 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6325 continue 6326 raise plumbing.convert_error_to_porcelain(e) from e 6327 break 6328 6329 resp = models.SecretEngineUpdateResponse() 6330 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6331 plumbing_response.meta) 6332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6333 plumbing_response.rate_limit) 6334 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6335 plumbing_response.secret_engine) 6336 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
6338 def delete(self, id, timeout=None): 6339 ''' 6340 Delete deletes a secret engine 6341 ''' 6342 deadline = None if timeout is None else time.time() + timeout 6343 req = SecretEngineDeleteRequest() 6344 6345 req.id = (id) 6346 tries = 0 6347 plumbing_response = None 6348 while True: 6349 t = None if deadline is None else deadline - time.time() 6350 try: 6351 plumbing_response = self.stub.Delete( 6352 req, 6353 metadata=self.parent.get_metadata('SecretEngines.Delete', 6354 req), 6355 timeout=t) 6356 except Exception as e: 6357 if self.parent.shouldRetry(tries, e, deadline): 6358 tries += 1 6359 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6360 continue 6361 raise plumbing.convert_error_to_porcelain(e) from e 6362 break 6363 6364 resp = models.SecretEngineDeleteResponse() 6365 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6366 plumbing_response.rate_limit) 6367 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
6369 def list_secret_stores(self, filter, *args, timeout=None): 6370 ''' 6371 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6372 for Secret Engine 6373 ''' 6374 deadline = None if timeout is None else time.time() + timeout 6375 req = SecretStoreListRequest() 6376 req.meta.CopyFrom(ListRequestMetadata()) 6377 if self.parent.page_limit > 0: 6378 req.meta.limit = self.parent.page_limit 6379 if self.parent.snapshot_datetime is not None: 6380 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6381 6382 req.filter = plumbing.quote_filter_args(filter, *args) 6383 6384 def generator(svc, req): 6385 tries = 0 6386 while True: 6387 t = None if deadline is None else deadline - time.time() 6388 try: 6389 plumbing_response = svc.stub.ListSecretStores( 6390 req, 6391 metadata=svc.parent.get_metadata( 6392 'SecretEngines.ListSecretStores', req), 6393 timeout=t) 6394 except Exception as e: 6395 if self.parent.shouldRetry(tries, e, deadline): 6396 tries += 1 6397 time.sleep( 6398 self.parent.exponentialBackoff(tries, deadline)) 6399 continue 6400 raise plumbing.convert_error_to_porcelain(e) from e 6401 tries = 0 6402 for plumbing_item in plumbing_response.secret_stores: 6403 yield plumbing.convert_secret_store_to_porcelain( 6404 plumbing_item) 6405 if plumbing_response.meta.next_cursor == '': 6406 break 6407 req.meta.cursor = plumbing_response.meta.next_cursor 6408 6409 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)
6411 def generate_keys(self, secret_engine_id, timeout=None): 6412 ''' 6413 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6414 ''' 6415 deadline = None if timeout is None else time.time() + timeout 6416 req = GenerateKeysRequest() 6417 6418 req.secret_engine_id = (secret_engine_id) 6419 tries = 0 6420 plumbing_response = None 6421 while True: 6422 t = None if deadline is None else deadline - time.time() 6423 try: 6424 plumbing_response = self.stub.GenerateKeys( 6425 req, 6426 metadata=self.parent.get_metadata( 6427 'SecretEngines.GenerateKeys', req), 6428 timeout=t) 6429 except Exception as e: 6430 if self.parent.shouldRetry(tries, e, deadline): 6431 tries += 1 6432 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6433 continue 6434 raise plumbing.convert_error_to_porcelain(e) from e 6435 break 6436 6437 resp = models.GenerateKeysResponse() 6438 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6439 plumbing_response.rate_limit) 6440 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)
6442 def healthcheck(self, secret_engine_id, timeout=None): 6443 ''' 6444 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6445 ''' 6446 deadline = None if timeout is None else time.time() + timeout 6447 req = HealthcheckRequest() 6448 6449 req.secret_engine_id = (secret_engine_id) 6450 tries = 0 6451 plumbing_response = None 6452 while True: 6453 t = None if deadline is None else deadline - time.time() 6454 try: 6455 plumbing_response = self.stub.Healthcheck( 6456 req, 6457 metadata=self.parent.get_metadata( 6458 'SecretEngines.Healthcheck', req), 6459 timeout=t) 6460 except Exception as e: 6461 if self.parent.shouldRetry(tries, e, deadline): 6462 tries += 1 6463 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6464 continue 6465 raise plumbing.convert_error_to_porcelain(e) from e 6466 break 6467 6468 resp = models.HealthcheckResponse() 6469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6470 plumbing_response.rate_limit) 6471 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6472 plumbing_response.status) 6473 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
6475 def rotate(self, id, password_policy, timeout=None): 6476 ''' 6477 Rotate rotates secret engine's credentials 6478 ''' 6479 deadline = None if timeout is None else time.time() + timeout 6480 req = SecretEngineRotateRequest() 6481 6482 req.id = (id) 6483 if password_policy is not None: 6484 req.password_policy.CopyFrom( 6485 plumbing.convert_secret_engine_password_policy_to_plumbing( 6486 password_policy)) 6487 tries = 0 6488 plumbing_response = None 6489 while True: 6490 t = None if deadline is None else deadline - time.time() 6491 try: 6492 plumbing_response = self.stub.Rotate( 6493 req, 6494 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6495 req), 6496 timeout=t) 6497 except Exception as e: 6498 if self.parent.shouldRetry(tries, e, deadline): 6499 tries += 1 6500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6501 continue 6502 raise plumbing.convert_error_to_porcelain(e) from e 6503 break 6504 6505 resp = models.SecretEngineRotateResponse() 6506 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6507 plumbing_response.rate_limit) 6508 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
6511class SecretStoreHealths: 6512 ''' 6513 SecretStoreHealths exposes health states for secret stores. 6514 See `strongdm.models.SecretStoreHealth`. 6515 ''' 6516 def __init__(self, channel, client): 6517 self.parent = client 6518 self.stub = SecretStoreHealthsStub(channel) 6519 6520 def list(self, filter, *args, timeout=None): 6521 ''' 6522 List reports the health status of node to secret store pairs. 6523 ''' 6524 deadline = None if timeout is None else time.time() + timeout 6525 req = SecretStoreHealthListRequest() 6526 req.meta.CopyFrom(ListRequestMetadata()) 6527 if self.parent.page_limit > 0: 6528 req.meta.limit = self.parent.page_limit 6529 if self.parent.snapshot_datetime is not None: 6530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6531 6532 req.filter = plumbing.quote_filter_args(filter, *args) 6533 6534 def generator(svc, req): 6535 tries = 0 6536 while True: 6537 t = None if deadline is None else deadline - time.time() 6538 try: 6539 plumbing_response = svc.stub.List( 6540 req, 6541 metadata=svc.parent.get_metadata( 6542 'SecretStoreHealths.List', req), 6543 timeout=t) 6544 except Exception as e: 6545 if self.parent.shouldRetry(tries, e, deadline): 6546 tries += 1 6547 time.sleep( 6548 self.parent.exponentialBackoff(tries, deadline)) 6549 continue 6550 raise plumbing.convert_error_to_porcelain(e) from e 6551 tries = 0 6552 for plumbing_item in plumbing_response.secret_store_healths: 6553 yield plumbing.convert_secret_store_health_to_porcelain( 6554 plumbing_item) 6555 if plumbing_response.meta.next_cursor == '': 6556 break 6557 req.meta.cursor = plumbing_response.meta.next_cursor 6558 6559 return generator(self, req) 6560 6561 def healthcheck(self, secret_store_id, timeout=None): 6562 ''' 6563 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6564 to propagate across a large network of Nodes. The call will return immediately, and the 6565 updated health of the Secret Store can be retrieved via List. 6566 ''' 6567 deadline = None if timeout is None else time.time() + timeout 6568 req = SecretStoreHealthcheckRequest() 6569 6570 req.secret_store_id = (secret_store_id) 6571 tries = 0 6572 plumbing_response = None 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = self.stub.Healthcheck( 6577 req, 6578 metadata=self.parent.get_metadata( 6579 'SecretStoreHealths.Healthcheck', req), 6580 timeout=t) 6581 except Exception as e: 6582 if self.parent.shouldRetry(tries, e, deadline): 6583 tries += 1 6584 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6585 continue 6586 raise plumbing.convert_error_to_porcelain(e) from e 6587 break 6588 6589 resp = models.SecretStoreHealthcheckResponse() 6590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6591 plumbing_response.rate_limit) 6592 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
6520 def list(self, filter, *args, timeout=None): 6521 ''' 6522 List reports the health status of node to secret store pairs. 6523 ''' 6524 deadline = None if timeout is None else time.time() + timeout 6525 req = SecretStoreHealthListRequest() 6526 req.meta.CopyFrom(ListRequestMetadata()) 6527 if self.parent.page_limit > 0: 6528 req.meta.limit = self.parent.page_limit 6529 if self.parent.snapshot_datetime is not None: 6530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6531 6532 req.filter = plumbing.quote_filter_args(filter, *args) 6533 6534 def generator(svc, req): 6535 tries = 0 6536 while True: 6537 t = None if deadline is None else deadline - time.time() 6538 try: 6539 plumbing_response = svc.stub.List( 6540 req, 6541 metadata=svc.parent.get_metadata( 6542 'SecretStoreHealths.List', req), 6543 timeout=t) 6544 except Exception as e: 6545 if self.parent.shouldRetry(tries, e, deadline): 6546 tries += 1 6547 time.sleep( 6548 self.parent.exponentialBackoff(tries, deadline)) 6549 continue 6550 raise plumbing.convert_error_to_porcelain(e) from e 6551 tries = 0 6552 for plumbing_item in plumbing_response.secret_store_healths: 6553 yield plumbing.convert_secret_store_health_to_porcelain( 6554 plumbing_item) 6555 if plumbing_response.meta.next_cursor == '': 6556 break 6557 req.meta.cursor = plumbing_response.meta.next_cursor 6558 6559 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
6561 def healthcheck(self, secret_store_id, timeout=None): 6562 ''' 6563 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6564 to propagate across a large network of Nodes. The call will return immediately, and the 6565 updated health of the Secret Store can be retrieved via List. 6566 ''' 6567 deadline = None if timeout is None else time.time() + timeout 6568 req = SecretStoreHealthcheckRequest() 6569 6570 req.secret_store_id = (secret_store_id) 6571 tries = 0 6572 plumbing_response = None 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = self.stub.Healthcheck( 6577 req, 6578 metadata=self.parent.get_metadata( 6579 'SecretStoreHealths.Healthcheck', req), 6580 timeout=t) 6581 except Exception as e: 6582 if self.parent.shouldRetry(tries, e, deadline): 6583 tries += 1 6584 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6585 continue 6586 raise plumbing.convert_error_to_porcelain(e) from e 6587 break 6588 6589 resp = models.SecretStoreHealthcheckResponse() 6590 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6591 plumbing_response.rate_limit) 6592 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:
6595class SecretStoresHistory: 6596 ''' 6597 SecretStoresHistory records all changes to the state of a SecretStore. 6598 See `strongdm.models.SecretStoreHistory`. 6599 ''' 6600 def __init__(self, channel, client): 6601 self.parent = client 6602 self.stub = SecretStoresHistoryStub(channel) 6603 6604 def list(self, filter, *args, timeout=None): 6605 ''' 6606 List gets a list of SecretStoreHistory records matching a given set of criteria. 6607 ''' 6608 deadline = None if timeout is None else time.time() + timeout 6609 req = SecretStoreHistoryListRequest() 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 'SecretStoresHistory.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_secret_store_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)
SecretStoresHistory records all changes to the state of a SecretStore.
See strongdm.models.SecretStoreHistory.
def
list(self, filter, *args, timeout=None)
6604 def list(self, filter, *args, timeout=None): 6605 ''' 6606 List gets a list of SecretStoreHistory records matching a given set of criteria. 6607 ''' 6608 deadline = None if timeout is None else time.time() + timeout 6609 req = SecretStoreHistoryListRequest() 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 'SecretStoresHistory.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_secret_store_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 SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
6646class WorkflowApprovers: 6647 ''' 6648 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6649 See `strongdm.models.WorkflowApprover`. 6650 ''' 6651 def __init__(self, channel, client): 6652 self.parent = client 6653 self.stub = WorkflowApproversStub(channel) 6654 6655 def create(self, workflow_approver, timeout=None): 6656 ''' 6657 Create creates a new workflow approver 6658 ''' 6659 deadline = None if timeout is None else time.time() + timeout 6660 req = WorkflowApproversCreateRequest() 6661 6662 if workflow_approver is not None: 6663 req.workflow_approver.CopyFrom( 6664 plumbing.convert_workflow_approver_to_plumbing( 6665 workflow_approver)) 6666 tries = 0 6667 plumbing_response = None 6668 while True: 6669 t = None if deadline is None else deadline - time.time() 6670 try: 6671 plumbing_response = self.stub.Create( 6672 req, 6673 metadata=self.parent.get_metadata( 6674 'WorkflowApprovers.Create', req), 6675 timeout=t) 6676 except Exception as e: 6677 if self.parent.shouldRetry(tries, e, deadline): 6678 tries += 1 6679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6680 continue 6681 raise plumbing.convert_error_to_porcelain(e) from e 6682 break 6683 6684 resp = models.WorkflowApproversCreateResponse() 6685 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6686 plumbing_response.rate_limit) 6687 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6688 plumbing_response.workflow_approver) 6689 return resp 6690 6691 def get(self, id, timeout=None): 6692 ''' 6693 Get reads one workflow approver by ID. 6694 ''' 6695 deadline = None if timeout is None else time.time() + timeout 6696 req = WorkflowApproverGetRequest() 6697 if self.parent.snapshot_datetime is not None: 6698 req.meta.CopyFrom(GetRequestMetadata()) 6699 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6700 6701 req.id = (id) 6702 tries = 0 6703 plumbing_response = None 6704 while True: 6705 t = None if deadline is None else deadline - time.time() 6706 try: 6707 plumbing_response = self.stub.Get( 6708 req, 6709 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6710 req), 6711 timeout=t) 6712 except Exception as e: 6713 if self.parent.shouldRetry(tries, e, deadline): 6714 tries += 1 6715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6716 continue 6717 raise plumbing.convert_error_to_porcelain(e) from e 6718 break 6719 6720 resp = models.WorkflowApproverGetResponse() 6721 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6722 plumbing_response.meta) 6723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6724 plumbing_response.rate_limit) 6725 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6726 plumbing_response.workflow_approver) 6727 return resp 6728 6729 def delete(self, id, timeout=None): 6730 ''' 6731 Delete deletes a workflow approver 6732 ''' 6733 deadline = None if timeout is None else time.time() + timeout 6734 req = WorkflowApproversDeleteRequest() 6735 6736 req.id = (id) 6737 tries = 0 6738 plumbing_response = None 6739 while True: 6740 t = None if deadline is None else deadline - time.time() 6741 try: 6742 plumbing_response = self.stub.Delete( 6743 req, 6744 metadata=self.parent.get_metadata( 6745 'WorkflowApprovers.Delete', req), 6746 timeout=t) 6747 except Exception as e: 6748 if self.parent.shouldRetry(tries, e, deadline): 6749 tries += 1 6750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6751 continue 6752 raise plumbing.convert_error_to_porcelain(e) from e 6753 break 6754 6755 resp = models.WorkflowApproversDeleteResponse() 6756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6757 plumbing_response.rate_limit) 6758 return resp 6759 6760 def list(self, filter, *args, timeout=None): 6761 ''' 6762 Lists existing workflow approvers. 6763 ''' 6764 deadline = None if timeout is None else time.time() + timeout 6765 req = WorkflowApproversListRequest() 6766 req.meta.CopyFrom(ListRequestMetadata()) 6767 if self.parent.page_limit > 0: 6768 req.meta.limit = self.parent.page_limit 6769 if self.parent.snapshot_datetime is not None: 6770 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6771 6772 req.filter = plumbing.quote_filter_args(filter, *args) 6773 6774 def generator(svc, req): 6775 tries = 0 6776 while True: 6777 t = None if deadline is None else deadline - time.time() 6778 try: 6779 plumbing_response = svc.stub.List( 6780 req, 6781 metadata=svc.parent.get_metadata( 6782 'WorkflowApprovers.List', req), 6783 timeout=t) 6784 except Exception as e: 6785 if self.parent.shouldRetry(tries, e, deadline): 6786 tries += 1 6787 time.sleep( 6788 self.parent.exponentialBackoff(tries, deadline)) 6789 continue 6790 raise plumbing.convert_error_to_porcelain(e) from e 6791 tries = 0 6792 for plumbing_item in plumbing_response.workflow_approvers: 6793 yield plumbing.convert_workflow_approver_to_porcelain( 6794 plumbing_item) 6795 if plumbing_response.meta.next_cursor == '': 6796 break 6797 req.meta.cursor = plumbing_response.meta.next_cursor 6798 6799 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)
6655 def create(self, workflow_approver, timeout=None): 6656 ''' 6657 Create creates a new workflow approver 6658 ''' 6659 deadline = None if timeout is None else time.time() + timeout 6660 req = WorkflowApproversCreateRequest() 6661 6662 if workflow_approver is not None: 6663 req.workflow_approver.CopyFrom( 6664 plumbing.convert_workflow_approver_to_plumbing( 6665 workflow_approver)) 6666 tries = 0 6667 plumbing_response = None 6668 while True: 6669 t = None if deadline is None else deadline - time.time() 6670 try: 6671 plumbing_response = self.stub.Create( 6672 req, 6673 metadata=self.parent.get_metadata( 6674 'WorkflowApprovers.Create', req), 6675 timeout=t) 6676 except Exception as e: 6677 if self.parent.shouldRetry(tries, e, deadline): 6678 tries += 1 6679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6680 continue 6681 raise plumbing.convert_error_to_porcelain(e) from e 6682 break 6683 6684 resp = models.WorkflowApproversCreateResponse() 6685 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6686 plumbing_response.rate_limit) 6687 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6688 plumbing_response.workflow_approver) 6689 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
6691 def get(self, id, timeout=None): 6692 ''' 6693 Get reads one workflow approver by ID. 6694 ''' 6695 deadline = None if timeout is None else time.time() + timeout 6696 req = WorkflowApproverGetRequest() 6697 if self.parent.snapshot_datetime is not None: 6698 req.meta.CopyFrom(GetRequestMetadata()) 6699 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6700 6701 req.id = (id) 6702 tries = 0 6703 plumbing_response = None 6704 while True: 6705 t = None if deadline is None else deadline - time.time() 6706 try: 6707 plumbing_response = self.stub.Get( 6708 req, 6709 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6710 req), 6711 timeout=t) 6712 except Exception as e: 6713 if self.parent.shouldRetry(tries, e, deadline): 6714 tries += 1 6715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6716 continue 6717 raise plumbing.convert_error_to_porcelain(e) from e 6718 break 6719 6720 resp = models.WorkflowApproverGetResponse() 6721 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6722 plumbing_response.meta) 6723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6724 plumbing_response.rate_limit) 6725 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6726 plumbing_response.workflow_approver) 6727 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
6729 def delete(self, id, timeout=None): 6730 ''' 6731 Delete deletes a workflow approver 6732 ''' 6733 deadline = None if timeout is None else time.time() + timeout 6734 req = WorkflowApproversDeleteRequest() 6735 6736 req.id = (id) 6737 tries = 0 6738 plumbing_response = None 6739 while True: 6740 t = None if deadline is None else deadline - time.time() 6741 try: 6742 plumbing_response = self.stub.Delete( 6743 req, 6744 metadata=self.parent.get_metadata( 6745 'WorkflowApprovers.Delete', req), 6746 timeout=t) 6747 except Exception as e: 6748 if self.parent.shouldRetry(tries, e, deadline): 6749 tries += 1 6750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6751 continue 6752 raise plumbing.convert_error_to_porcelain(e) from e 6753 break 6754 6755 resp = models.WorkflowApproversDeleteResponse() 6756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6757 plumbing_response.rate_limit) 6758 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
6760 def list(self, filter, *args, timeout=None): 6761 ''' 6762 Lists existing workflow approvers. 6763 ''' 6764 deadline = None if timeout is None else time.time() + timeout 6765 req = WorkflowApproversListRequest() 6766 req.meta.CopyFrom(ListRequestMetadata()) 6767 if self.parent.page_limit > 0: 6768 req.meta.limit = self.parent.page_limit 6769 if self.parent.snapshot_datetime is not None: 6770 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6771 6772 req.filter = plumbing.quote_filter_args(filter, *args) 6773 6774 def generator(svc, req): 6775 tries = 0 6776 while True: 6777 t = None if deadline is None else deadline - time.time() 6778 try: 6779 plumbing_response = svc.stub.List( 6780 req, 6781 metadata=svc.parent.get_metadata( 6782 'WorkflowApprovers.List', req), 6783 timeout=t) 6784 except Exception as e: 6785 if self.parent.shouldRetry(tries, e, deadline): 6786 tries += 1 6787 time.sleep( 6788 self.parent.exponentialBackoff(tries, deadline)) 6789 continue 6790 raise plumbing.convert_error_to_porcelain(e) from e 6791 tries = 0 6792 for plumbing_item in plumbing_response.workflow_approvers: 6793 yield plumbing.convert_workflow_approver_to_porcelain( 6794 plumbing_item) 6795 if plumbing_response.meta.next_cursor == '': 6796 break 6797 req.meta.cursor = plumbing_response.meta.next_cursor 6798 6799 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
6802class SnapshotWorkflowApprovers: 6803 ''' 6804 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6805 service for historical queries. 6806 ''' 6807 def __init__(self, workflow_approvers): 6808 self.workflow_approvers = workflow_approvers 6809 6810 def get(self, id, timeout=None): 6811 ''' 6812 Get reads one workflow approver by ID. 6813 ''' 6814 return self.workflow_approvers.get(id, timeout=timeout) 6815 6816 def list(self, filter, *args, timeout=None): 6817 ''' 6818 Lists existing workflow approvers. 6819 ''' 6820 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
6823class WorkflowApproversHistory: 6824 ''' 6825 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6826 See `strongdm.models.WorkflowApproverHistory`. 6827 ''' 6828 def __init__(self, channel, client): 6829 self.parent = client 6830 self.stub = WorkflowApproversHistoryStub(channel) 6831 6832 def list(self, filter, *args, timeout=None): 6833 ''' 6834 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6835 ''' 6836 deadline = None if timeout is None else time.time() + timeout 6837 req = WorkflowApproversHistoryListRequest() 6838 req.meta.CopyFrom(ListRequestMetadata()) 6839 if self.parent.page_limit > 0: 6840 req.meta.limit = self.parent.page_limit 6841 if self.parent.snapshot_datetime is not None: 6842 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6843 6844 req.filter = plumbing.quote_filter_args(filter, *args) 6845 6846 def generator(svc, req): 6847 tries = 0 6848 while True: 6849 t = None if deadline is None else deadline - time.time() 6850 try: 6851 plumbing_response = svc.stub.List( 6852 req, 6853 metadata=svc.parent.get_metadata( 6854 'WorkflowApproversHistory.List', req), 6855 timeout=t) 6856 except Exception as e: 6857 if self.parent.shouldRetry(tries, e, deadline): 6858 tries += 1 6859 time.sleep( 6860 self.parent.exponentialBackoff(tries, deadline)) 6861 continue 6862 raise plumbing.convert_error_to_porcelain(e) from e 6863 tries = 0 6864 for plumbing_item in plumbing_response.history: 6865 yield plumbing.convert_workflow_approver_history_to_porcelain( 6866 plumbing_item) 6867 if plumbing_response.meta.next_cursor == '': 6868 break 6869 req.meta.cursor = plumbing_response.meta.next_cursor 6870 6871 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)
6832 def list(self, filter, *args, timeout=None): 6833 ''' 6834 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6835 ''' 6836 deadline = None if timeout is None else time.time() + timeout 6837 req = WorkflowApproversHistoryListRequest() 6838 req.meta.CopyFrom(ListRequestMetadata()) 6839 if self.parent.page_limit > 0: 6840 req.meta.limit = self.parent.page_limit 6841 if self.parent.snapshot_datetime is not None: 6842 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6843 6844 req.filter = plumbing.quote_filter_args(filter, *args) 6845 6846 def generator(svc, req): 6847 tries = 0 6848 while True: 6849 t = None if deadline is None else deadline - time.time() 6850 try: 6851 plumbing_response = svc.stub.List( 6852 req, 6853 metadata=svc.parent.get_metadata( 6854 'WorkflowApproversHistory.List', req), 6855 timeout=t) 6856 except Exception as e: 6857 if self.parent.shouldRetry(tries, e, deadline): 6858 tries += 1 6859 time.sleep( 6860 self.parent.exponentialBackoff(tries, deadline)) 6861 continue 6862 raise plumbing.convert_error_to_porcelain(e) from e 6863 tries = 0 6864 for plumbing_item in plumbing_response.history: 6865 yield plumbing.convert_workflow_approver_history_to_porcelain( 6866 plumbing_item) 6867 if plumbing_response.meta.next_cursor == '': 6868 break 6869 req.meta.cursor = plumbing_response.meta.next_cursor 6870 6871 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
6874class WorkflowRoles: 6875 ''' 6876 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6877 to request access to a resource via the workflow. 6878 See `strongdm.models.WorkflowRole`. 6879 ''' 6880 def __init__(self, channel, client): 6881 self.parent = client 6882 self.stub = WorkflowRolesStub(channel) 6883 6884 def create(self, workflow_role, timeout=None): 6885 ''' 6886 Create creates a new workflow role 6887 ''' 6888 deadline = None if timeout is None else time.time() + timeout 6889 req = WorkflowRolesCreateRequest() 6890 6891 if workflow_role is not None: 6892 req.workflow_role.CopyFrom( 6893 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6894 tries = 0 6895 plumbing_response = None 6896 while True: 6897 t = None if deadline is None else deadline - time.time() 6898 try: 6899 plumbing_response = self.stub.Create( 6900 req, 6901 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6902 req), 6903 timeout=t) 6904 except Exception as e: 6905 if self.parent.shouldRetry(tries, e, deadline): 6906 tries += 1 6907 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6908 continue 6909 raise plumbing.convert_error_to_porcelain(e) from e 6910 break 6911 6912 resp = models.WorkflowRolesCreateResponse() 6913 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6914 plumbing_response.rate_limit) 6915 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6916 plumbing_response.workflow_role) 6917 return resp 6918 6919 def get(self, id, timeout=None): 6920 ''' 6921 Get reads one workflow role by ID. 6922 ''' 6923 deadline = None if timeout is None else time.time() + timeout 6924 req = WorkflowRoleGetRequest() 6925 if self.parent.snapshot_datetime is not None: 6926 req.meta.CopyFrom(GetRequestMetadata()) 6927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6928 6929 req.id = (id) 6930 tries = 0 6931 plumbing_response = None 6932 while True: 6933 t = None if deadline is None else deadline - time.time() 6934 try: 6935 plumbing_response = self.stub.Get( 6936 req, 6937 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6938 req), 6939 timeout=t) 6940 except Exception as e: 6941 if self.parent.shouldRetry(tries, e, deadline): 6942 tries += 1 6943 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6944 continue 6945 raise plumbing.convert_error_to_porcelain(e) from e 6946 break 6947 6948 resp = models.WorkflowRoleGetResponse() 6949 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6950 plumbing_response.meta) 6951 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6952 plumbing_response.rate_limit) 6953 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6954 plumbing_response.workflow_role) 6955 return resp 6956 6957 def delete(self, id, timeout=None): 6958 ''' 6959 Delete deletes a workflow role 6960 ''' 6961 deadline = None if timeout is None else time.time() + timeout 6962 req = WorkflowRolesDeleteRequest() 6963 6964 req.id = (id) 6965 tries = 0 6966 plumbing_response = None 6967 while True: 6968 t = None if deadline is None else deadline - time.time() 6969 try: 6970 plumbing_response = self.stub.Delete( 6971 req, 6972 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6973 req), 6974 timeout=t) 6975 except Exception as e: 6976 if self.parent.shouldRetry(tries, e, deadline): 6977 tries += 1 6978 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6979 continue 6980 raise plumbing.convert_error_to_porcelain(e) from e 6981 break 6982 6983 resp = models.WorkflowRolesDeleteResponse() 6984 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6985 plumbing_response.rate_limit) 6986 return resp 6987 6988 def list(self, filter, *args, timeout=None): 6989 ''' 6990 Lists existing workflow roles. 6991 ''' 6992 deadline = None if timeout is None else time.time() + timeout 6993 req = WorkflowRolesListRequest() 6994 req.meta.CopyFrom(ListRequestMetadata()) 6995 if self.parent.page_limit > 0: 6996 req.meta.limit = self.parent.page_limit 6997 if self.parent.snapshot_datetime is not None: 6998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6999 7000 req.filter = plumbing.quote_filter_args(filter, *args) 7001 7002 def generator(svc, req): 7003 tries = 0 7004 while True: 7005 t = None if deadline is None else deadline - time.time() 7006 try: 7007 plumbing_response = svc.stub.List( 7008 req, 7009 metadata=svc.parent.get_metadata( 7010 'WorkflowRoles.List', req), 7011 timeout=t) 7012 except Exception as e: 7013 if self.parent.shouldRetry(tries, e, deadline): 7014 tries += 1 7015 time.sleep( 7016 self.parent.exponentialBackoff(tries, deadline)) 7017 continue 7018 raise plumbing.convert_error_to_porcelain(e) from e 7019 tries = 0 7020 for plumbing_item in plumbing_response.workflow_role: 7021 yield plumbing.convert_workflow_role_to_porcelain( 7022 plumbing_item) 7023 if plumbing_response.meta.next_cursor == '': 7024 break 7025 req.meta.cursor = plumbing_response.meta.next_cursor 7026 7027 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)
6884 def create(self, workflow_role, timeout=None): 6885 ''' 6886 Create creates a new workflow role 6887 ''' 6888 deadline = None if timeout is None else time.time() + timeout 6889 req = WorkflowRolesCreateRequest() 6890 6891 if workflow_role is not None: 6892 req.workflow_role.CopyFrom( 6893 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6894 tries = 0 6895 plumbing_response = None 6896 while True: 6897 t = None if deadline is None else deadline - time.time() 6898 try: 6899 plumbing_response = self.stub.Create( 6900 req, 6901 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6902 req), 6903 timeout=t) 6904 except Exception as e: 6905 if self.parent.shouldRetry(tries, e, deadline): 6906 tries += 1 6907 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6908 continue 6909 raise plumbing.convert_error_to_porcelain(e) from e 6910 break 6911 6912 resp = models.WorkflowRolesCreateResponse() 6913 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6914 plumbing_response.rate_limit) 6915 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6916 plumbing_response.workflow_role) 6917 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
6919 def get(self, id, timeout=None): 6920 ''' 6921 Get reads one workflow role by ID. 6922 ''' 6923 deadline = None if timeout is None else time.time() + timeout 6924 req = WorkflowRoleGetRequest() 6925 if self.parent.snapshot_datetime is not None: 6926 req.meta.CopyFrom(GetRequestMetadata()) 6927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6928 6929 req.id = (id) 6930 tries = 0 6931 plumbing_response = None 6932 while True: 6933 t = None if deadline is None else deadline - time.time() 6934 try: 6935 plumbing_response = self.stub.Get( 6936 req, 6937 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6938 req), 6939 timeout=t) 6940 except Exception as e: 6941 if self.parent.shouldRetry(tries, e, deadline): 6942 tries += 1 6943 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6944 continue 6945 raise plumbing.convert_error_to_porcelain(e) from e 6946 break 6947 6948 resp = models.WorkflowRoleGetResponse() 6949 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6950 plumbing_response.meta) 6951 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6952 plumbing_response.rate_limit) 6953 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6954 plumbing_response.workflow_role) 6955 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
6957 def delete(self, id, timeout=None): 6958 ''' 6959 Delete deletes a workflow role 6960 ''' 6961 deadline = None if timeout is None else time.time() + timeout 6962 req = WorkflowRolesDeleteRequest() 6963 6964 req.id = (id) 6965 tries = 0 6966 plumbing_response = None 6967 while True: 6968 t = None if deadline is None else deadline - time.time() 6969 try: 6970 plumbing_response = self.stub.Delete( 6971 req, 6972 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6973 req), 6974 timeout=t) 6975 except Exception as e: 6976 if self.parent.shouldRetry(tries, e, deadline): 6977 tries += 1 6978 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6979 continue 6980 raise plumbing.convert_error_to_porcelain(e) from e 6981 break 6982 6983 resp = models.WorkflowRolesDeleteResponse() 6984 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6985 plumbing_response.rate_limit) 6986 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
6988 def list(self, filter, *args, timeout=None): 6989 ''' 6990 Lists existing workflow roles. 6991 ''' 6992 deadline = None if timeout is None else time.time() + timeout 6993 req = WorkflowRolesListRequest() 6994 req.meta.CopyFrom(ListRequestMetadata()) 6995 if self.parent.page_limit > 0: 6996 req.meta.limit = self.parent.page_limit 6997 if self.parent.snapshot_datetime is not None: 6998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6999 7000 req.filter = plumbing.quote_filter_args(filter, *args) 7001 7002 def generator(svc, req): 7003 tries = 0 7004 while True: 7005 t = None if deadline is None else deadline - time.time() 7006 try: 7007 plumbing_response = svc.stub.List( 7008 req, 7009 metadata=svc.parent.get_metadata( 7010 'WorkflowRoles.List', req), 7011 timeout=t) 7012 except Exception as e: 7013 if self.parent.shouldRetry(tries, e, deadline): 7014 tries += 1 7015 time.sleep( 7016 self.parent.exponentialBackoff(tries, deadline)) 7017 continue 7018 raise plumbing.convert_error_to_porcelain(e) from e 7019 tries = 0 7020 for plumbing_item in plumbing_response.workflow_role: 7021 yield plumbing.convert_workflow_role_to_porcelain( 7022 plumbing_item) 7023 if plumbing_response.meta.next_cursor == '': 7024 break 7025 req.meta.cursor = plumbing_response.meta.next_cursor 7026 7027 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
7030class SnapshotWorkflowRoles: 7031 ''' 7032 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7033 service for historical queries. 7034 ''' 7035 def __init__(self, workflow_roles): 7036 self.workflow_roles = workflow_roles 7037 7038 def get(self, id, timeout=None): 7039 ''' 7040 Get reads one workflow role by ID. 7041 ''' 7042 return self.workflow_roles.get(id, timeout=timeout) 7043 7044 def list(self, filter, *args, timeout=None): 7045 ''' 7046 Lists existing workflow roles. 7047 ''' 7048 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
7051class WorkflowRolesHistory: 7052 ''' 7053 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7054 See `strongdm.models.WorkflowRoleHistory`. 7055 ''' 7056 def __init__(self, channel, client): 7057 self.parent = client 7058 self.stub = WorkflowRolesHistoryStub(channel) 7059 7060 def list(self, filter, *args, timeout=None): 7061 ''' 7062 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7063 ''' 7064 deadline = None if timeout is None else time.time() + timeout 7065 req = WorkflowRolesHistoryListRequest() 7066 req.meta.CopyFrom(ListRequestMetadata()) 7067 if self.parent.page_limit > 0: 7068 req.meta.limit = self.parent.page_limit 7069 if self.parent.snapshot_datetime is not None: 7070 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7071 7072 req.filter = plumbing.quote_filter_args(filter, *args) 7073 7074 def generator(svc, req): 7075 tries = 0 7076 while True: 7077 t = None if deadline is None else deadline - time.time() 7078 try: 7079 plumbing_response = svc.stub.List( 7080 req, 7081 metadata=svc.parent.get_metadata( 7082 'WorkflowRolesHistory.List', req), 7083 timeout=t) 7084 except Exception as e: 7085 if self.parent.shouldRetry(tries, e, deadline): 7086 tries += 1 7087 time.sleep( 7088 self.parent.exponentialBackoff(tries, deadline)) 7089 continue 7090 raise plumbing.convert_error_to_porcelain(e) from e 7091 tries = 0 7092 for plumbing_item in plumbing_response.history: 7093 yield plumbing.convert_workflow_role_history_to_porcelain( 7094 plumbing_item) 7095 if plumbing_response.meta.next_cursor == '': 7096 break 7097 req.meta.cursor = plumbing_response.meta.next_cursor 7098 7099 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)
7060 def list(self, filter, *args, timeout=None): 7061 ''' 7062 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7063 ''' 7064 deadline = None if timeout is None else time.time() + timeout 7065 req = WorkflowRolesHistoryListRequest() 7066 req.meta.CopyFrom(ListRequestMetadata()) 7067 if self.parent.page_limit > 0: 7068 req.meta.limit = self.parent.page_limit 7069 if self.parent.snapshot_datetime is not None: 7070 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7071 7072 req.filter = plumbing.quote_filter_args(filter, *args) 7073 7074 def generator(svc, req): 7075 tries = 0 7076 while True: 7077 t = None if deadline is None else deadline - time.time() 7078 try: 7079 plumbing_response = svc.stub.List( 7080 req, 7081 metadata=svc.parent.get_metadata( 7082 'WorkflowRolesHistory.List', req), 7083 timeout=t) 7084 except Exception as e: 7085 if self.parent.shouldRetry(tries, e, deadline): 7086 tries += 1 7087 time.sleep( 7088 self.parent.exponentialBackoff(tries, deadline)) 7089 continue 7090 raise plumbing.convert_error_to_porcelain(e) from e 7091 tries = 0 7092 for plumbing_item in plumbing_response.history: 7093 yield plumbing.convert_workflow_role_history_to_porcelain( 7094 plumbing_item) 7095 if plumbing_response.meta.next_cursor == '': 7096 break 7097 req.meta.cursor = plumbing_response.meta.next_cursor 7098 7099 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
7102class Workflows: 7103 ''' 7104 Workflows are the collection of rules that define the resources to which access can be requested, 7105 the users that can request that access, and the mechanism for approving those requests which can either 7106 be automatic approval or a set of users authorized to approve the requests. 7107 See `strongdm.models.Workflow`. 7108 ''' 7109 def __init__(self, channel, client): 7110 self.parent = client 7111 self.stub = WorkflowsStub(channel) 7112 7113 def create(self, workflow, timeout=None): 7114 ''' 7115 Create creates a new workflow and requires a name for the workflow. 7116 ''' 7117 deadline = None if timeout is None else time.time() + timeout 7118 req = WorkflowCreateRequest() 7119 7120 if workflow is not None: 7121 req.workflow.CopyFrom( 7122 plumbing.convert_workflow_to_plumbing(workflow)) 7123 tries = 0 7124 plumbing_response = None 7125 while True: 7126 t = None if deadline is None else deadline - time.time() 7127 try: 7128 plumbing_response = self.stub.Create( 7129 req, 7130 metadata=self.parent.get_metadata('Workflows.Create', req), 7131 timeout=t) 7132 except Exception as e: 7133 if self.parent.shouldRetry(tries, e, deadline): 7134 tries += 1 7135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7136 continue 7137 raise plumbing.convert_error_to_porcelain(e) from e 7138 break 7139 7140 resp = models.WorkflowCreateResponse() 7141 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7142 plumbing_response.rate_limit) 7143 resp.workflow = plumbing.convert_workflow_to_porcelain( 7144 plumbing_response.workflow) 7145 return resp 7146 7147 def get(self, id, timeout=None): 7148 ''' 7149 Get reads one workflow by ID. 7150 ''' 7151 deadline = None if timeout is None else time.time() + timeout 7152 req = WorkflowGetRequest() 7153 if self.parent.snapshot_datetime is not None: 7154 req.meta.CopyFrom(GetRequestMetadata()) 7155 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7156 7157 req.id = (id) 7158 tries = 0 7159 plumbing_response = None 7160 while True: 7161 t = None if deadline is None else deadline - time.time() 7162 try: 7163 plumbing_response = self.stub.Get( 7164 req, 7165 metadata=self.parent.get_metadata('Workflows.Get', req), 7166 timeout=t) 7167 except Exception as e: 7168 if self.parent.shouldRetry(tries, e, deadline): 7169 tries += 1 7170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7171 continue 7172 raise plumbing.convert_error_to_porcelain(e) from e 7173 break 7174 7175 resp = models.WorkflowGetResponse() 7176 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7177 plumbing_response.meta) 7178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7179 plumbing_response.rate_limit) 7180 resp.workflow = plumbing.convert_workflow_to_porcelain( 7181 plumbing_response.workflow) 7182 return resp 7183 7184 def delete(self, id, timeout=None): 7185 ''' 7186 Delete deletes an existing workflow. 7187 ''' 7188 deadline = None if timeout is None else time.time() + timeout 7189 req = WorkflowDeleteRequest() 7190 7191 req.id = (id) 7192 tries = 0 7193 plumbing_response = None 7194 while True: 7195 t = None if deadline is None else deadline - time.time() 7196 try: 7197 plumbing_response = self.stub.Delete( 7198 req, 7199 metadata=self.parent.get_metadata('Workflows.Delete', req), 7200 timeout=t) 7201 except Exception as e: 7202 if self.parent.shouldRetry(tries, e, deadline): 7203 tries += 1 7204 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7205 continue 7206 raise plumbing.convert_error_to_porcelain(e) from e 7207 break 7208 7209 resp = models.WorkflowDeleteResponse() 7210 resp.id = (plumbing_response.id) 7211 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7212 plumbing_response.rate_limit) 7213 return resp 7214 7215 def update(self, workflow, timeout=None): 7216 ''' 7217 Update updates an existing workflow. 7218 ''' 7219 deadline = None if timeout is None else time.time() + timeout 7220 req = WorkflowUpdateRequest() 7221 7222 if workflow is not None: 7223 req.workflow.CopyFrom( 7224 plumbing.convert_workflow_to_plumbing(workflow)) 7225 tries = 0 7226 plumbing_response = None 7227 while True: 7228 t = None if deadline is None else deadline - time.time() 7229 try: 7230 plumbing_response = self.stub.Update( 7231 req, 7232 metadata=self.parent.get_metadata('Workflows.Update', req), 7233 timeout=t) 7234 except Exception as e: 7235 if self.parent.shouldRetry(tries, e, deadline): 7236 tries += 1 7237 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7238 continue 7239 raise plumbing.convert_error_to_porcelain(e) from e 7240 break 7241 7242 resp = models.WorkflowUpdateResponse() 7243 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7244 plumbing_response.rate_limit) 7245 resp.workflow = plumbing.convert_workflow_to_porcelain( 7246 plumbing_response.workflow) 7247 return resp 7248 7249 def list(self, filter, *args, timeout=None): 7250 ''' 7251 Lists existing workflows. 7252 ''' 7253 deadline = None if timeout is None else time.time() + timeout 7254 req = WorkflowListRequest() 7255 req.meta.CopyFrom(ListRequestMetadata()) 7256 if self.parent.page_limit > 0: 7257 req.meta.limit = self.parent.page_limit 7258 if self.parent.snapshot_datetime is not None: 7259 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7260 7261 req.filter = plumbing.quote_filter_args(filter, *args) 7262 7263 def generator(svc, req): 7264 tries = 0 7265 while True: 7266 t = None if deadline is None else deadline - time.time() 7267 try: 7268 plumbing_response = svc.stub.List( 7269 req, 7270 metadata=svc.parent.get_metadata( 7271 'Workflows.List', req), 7272 timeout=t) 7273 except Exception as e: 7274 if self.parent.shouldRetry(tries, e, deadline): 7275 tries += 1 7276 time.sleep( 7277 self.parent.exponentialBackoff(tries, deadline)) 7278 continue 7279 raise plumbing.convert_error_to_porcelain(e) from e 7280 tries = 0 7281 for plumbing_item in plumbing_response.workflows: 7282 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7283 if plumbing_response.meta.next_cursor == '': 7284 break 7285 req.meta.cursor = plumbing_response.meta.next_cursor 7286 7287 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)
7113 def create(self, workflow, timeout=None): 7114 ''' 7115 Create creates a new workflow and requires a name for the workflow. 7116 ''' 7117 deadline = None if timeout is None else time.time() + timeout 7118 req = WorkflowCreateRequest() 7119 7120 if workflow is not None: 7121 req.workflow.CopyFrom( 7122 plumbing.convert_workflow_to_plumbing(workflow)) 7123 tries = 0 7124 plumbing_response = None 7125 while True: 7126 t = None if deadline is None else deadline - time.time() 7127 try: 7128 plumbing_response = self.stub.Create( 7129 req, 7130 metadata=self.parent.get_metadata('Workflows.Create', req), 7131 timeout=t) 7132 except Exception as e: 7133 if self.parent.shouldRetry(tries, e, deadline): 7134 tries += 1 7135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7136 continue 7137 raise plumbing.convert_error_to_porcelain(e) from e 7138 break 7139 7140 resp = models.WorkflowCreateResponse() 7141 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7142 plumbing_response.rate_limit) 7143 resp.workflow = plumbing.convert_workflow_to_porcelain( 7144 plumbing_response.workflow) 7145 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
7147 def get(self, id, timeout=None): 7148 ''' 7149 Get reads one workflow by ID. 7150 ''' 7151 deadline = None if timeout is None else time.time() + timeout 7152 req = WorkflowGetRequest() 7153 if self.parent.snapshot_datetime is not None: 7154 req.meta.CopyFrom(GetRequestMetadata()) 7155 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7156 7157 req.id = (id) 7158 tries = 0 7159 plumbing_response = None 7160 while True: 7161 t = None if deadline is None else deadline - time.time() 7162 try: 7163 plumbing_response = self.stub.Get( 7164 req, 7165 metadata=self.parent.get_metadata('Workflows.Get', req), 7166 timeout=t) 7167 except Exception as e: 7168 if self.parent.shouldRetry(tries, e, deadline): 7169 tries += 1 7170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7171 continue 7172 raise plumbing.convert_error_to_porcelain(e) from e 7173 break 7174 7175 resp = models.WorkflowGetResponse() 7176 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7177 plumbing_response.meta) 7178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7179 plumbing_response.rate_limit) 7180 resp.workflow = plumbing.convert_workflow_to_porcelain( 7181 plumbing_response.workflow) 7182 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
7184 def delete(self, id, timeout=None): 7185 ''' 7186 Delete deletes an existing workflow. 7187 ''' 7188 deadline = None if timeout is None else time.time() + timeout 7189 req = WorkflowDeleteRequest() 7190 7191 req.id = (id) 7192 tries = 0 7193 plumbing_response = None 7194 while True: 7195 t = None if deadline is None else deadline - time.time() 7196 try: 7197 plumbing_response = self.stub.Delete( 7198 req, 7199 metadata=self.parent.get_metadata('Workflows.Delete', req), 7200 timeout=t) 7201 except Exception as e: 7202 if self.parent.shouldRetry(tries, e, deadline): 7203 tries += 1 7204 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7205 continue 7206 raise plumbing.convert_error_to_porcelain(e) from e 7207 break 7208 7209 resp = models.WorkflowDeleteResponse() 7210 resp.id = (plumbing_response.id) 7211 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7212 plumbing_response.rate_limit) 7213 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
7215 def update(self, workflow, timeout=None): 7216 ''' 7217 Update updates an existing workflow. 7218 ''' 7219 deadline = None if timeout is None else time.time() + timeout 7220 req = WorkflowUpdateRequest() 7221 7222 if workflow is not None: 7223 req.workflow.CopyFrom( 7224 plumbing.convert_workflow_to_plumbing(workflow)) 7225 tries = 0 7226 plumbing_response = None 7227 while True: 7228 t = None if deadline is None else deadline - time.time() 7229 try: 7230 plumbing_response = self.stub.Update( 7231 req, 7232 metadata=self.parent.get_metadata('Workflows.Update', req), 7233 timeout=t) 7234 except Exception as e: 7235 if self.parent.shouldRetry(tries, e, deadline): 7236 tries += 1 7237 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7238 continue 7239 raise plumbing.convert_error_to_porcelain(e) from e 7240 break 7241 7242 resp = models.WorkflowUpdateResponse() 7243 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7244 plumbing_response.rate_limit) 7245 resp.workflow = plumbing.convert_workflow_to_porcelain( 7246 plumbing_response.workflow) 7247 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
7249 def list(self, filter, *args, timeout=None): 7250 ''' 7251 Lists existing workflows. 7252 ''' 7253 deadline = None if timeout is None else time.time() + timeout 7254 req = WorkflowListRequest() 7255 req.meta.CopyFrom(ListRequestMetadata()) 7256 if self.parent.page_limit > 0: 7257 req.meta.limit = self.parent.page_limit 7258 if self.parent.snapshot_datetime is not None: 7259 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7260 7261 req.filter = plumbing.quote_filter_args(filter, *args) 7262 7263 def generator(svc, req): 7264 tries = 0 7265 while True: 7266 t = None if deadline is None else deadline - time.time() 7267 try: 7268 plumbing_response = svc.stub.List( 7269 req, 7270 metadata=svc.parent.get_metadata( 7271 'Workflows.List', req), 7272 timeout=t) 7273 except Exception as e: 7274 if self.parent.shouldRetry(tries, e, deadline): 7275 tries += 1 7276 time.sleep( 7277 self.parent.exponentialBackoff(tries, deadline)) 7278 continue 7279 raise plumbing.convert_error_to_porcelain(e) from e 7280 tries = 0 7281 for plumbing_item in plumbing_response.workflows: 7282 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7283 if plumbing_response.meta.next_cursor == '': 7284 break 7285 req.meta.cursor = plumbing_response.meta.next_cursor 7286 7287 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
7290class SnapshotWorkflows: 7291 ''' 7292 SnapshotWorkflows exposes the read only methods of the Workflows 7293 service for historical queries. 7294 ''' 7295 def __init__(self, workflows): 7296 self.workflows = workflows 7297 7298 def get(self, id, timeout=None): 7299 ''' 7300 Get reads one workflow by ID. 7301 ''' 7302 return self.workflows.get(id, timeout=timeout) 7303 7304 def list(self, filter, *args, timeout=None): 7305 ''' 7306 Lists existing workflows. 7307 ''' 7308 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
7311class WorkflowsHistory: 7312 ''' 7313 WorkflowsHistory provides records of all changes to the state of a Workflow. 7314 See `strongdm.models.WorkflowHistory`. 7315 ''' 7316 def __init__(self, channel, client): 7317 self.parent = client 7318 self.stub = WorkflowsHistoryStub(channel) 7319 7320 def list(self, filter, *args, timeout=None): 7321 ''' 7322 List gets a list of WorkflowHistory records matching a given set of criteria. 7323 ''' 7324 deadline = None if timeout is None else time.time() + timeout 7325 req = WorkflowHistoryListRequest() 7326 req.meta.CopyFrom(ListRequestMetadata()) 7327 if self.parent.page_limit > 0: 7328 req.meta.limit = self.parent.page_limit 7329 if self.parent.snapshot_datetime is not None: 7330 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7331 7332 req.filter = plumbing.quote_filter_args(filter, *args) 7333 7334 def generator(svc, req): 7335 tries = 0 7336 while True: 7337 t = None if deadline is None else deadline - time.time() 7338 try: 7339 plumbing_response = svc.stub.List( 7340 req, 7341 metadata=svc.parent.get_metadata( 7342 'WorkflowsHistory.List', req), 7343 timeout=t) 7344 except Exception as e: 7345 if self.parent.shouldRetry(tries, e, deadline): 7346 tries += 1 7347 time.sleep( 7348 self.parent.exponentialBackoff(tries, deadline)) 7349 continue 7350 raise plumbing.convert_error_to_porcelain(e) from e 7351 tries = 0 7352 for plumbing_item in plumbing_response.history: 7353 yield plumbing.convert_workflow_history_to_porcelain( 7354 plumbing_item) 7355 if plumbing_response.meta.next_cursor == '': 7356 break 7357 req.meta.cursor = plumbing_response.meta.next_cursor 7358 7359 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)
7320 def list(self, filter, *args, timeout=None): 7321 ''' 7322 List gets a list of WorkflowHistory records matching a given set of criteria. 7323 ''' 7324 deadline = None if timeout is None else time.time() + timeout 7325 req = WorkflowHistoryListRequest() 7326 req.meta.CopyFrom(ListRequestMetadata()) 7327 if self.parent.page_limit > 0: 7328 req.meta.limit = self.parent.page_limit 7329 if self.parent.snapshot_datetime is not None: 7330 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7331 7332 req.filter = plumbing.quote_filter_args(filter, *args) 7333 7334 def generator(svc, req): 7335 tries = 0 7336 while True: 7337 t = None if deadline is None else deadline - time.time() 7338 try: 7339 plumbing_response = svc.stub.List( 7340 req, 7341 metadata=svc.parent.get_metadata( 7342 'WorkflowsHistory.List', req), 7343 timeout=t) 7344 except Exception as e: 7345 if self.parent.shouldRetry(tries, e, deadline): 7346 tries += 1 7347 time.sleep( 7348 self.parent.exponentialBackoff(tries, deadline)) 7349 continue 7350 raise plumbing.convert_error_to_porcelain(e) from e 7351 tries = 0 7352 for plumbing_item in plumbing_response.history: 7353 yield plumbing.convert_workflow_history_to_porcelain( 7354 plumbing_item) 7355 if plumbing_response.meta.next_cursor == '': 7356 break 7357 req.meta.cursor = plumbing_response.meta.next_cursor 7358 7359 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.