strongdm.svc
1# Copyright 2020 StrongDM Inc 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# 15 16# Code generated by protogen. DO NOT EDIT. 17 18import grpc 19from . import plumbing 20from . import models 21from .options_pb2 import * 22from .options_pb2_grpc import * 23from .spec_pb2 import * 24from .spec_pb2_grpc import * 25from .tags_pb2 import * 26from .tags_pb2_grpc import * 27from .access_requests_pb2 import * 28from .access_requests_pb2_grpc import * 29from .access_request_events_history_pb2 import * 30from .access_request_events_history_pb2_grpc import * 31from .access_requests_history_pb2 import * 32from .access_requests_history_pb2_grpc import * 33from .drivers_pb2 import * 34from .drivers_pb2_grpc import * 35from .account_attachments_pb2 import * 36from .account_attachments_pb2_grpc import * 37from .account_attachments_history_pb2 import * 38from .account_attachments_history_pb2_grpc import * 39from .account_grants_pb2 import * 40from .account_grants_pb2_grpc import * 41from .account_grants_history_pb2 import * 42from .account_grants_history_pb2_grpc import * 43from .account_permissions_pb2 import * 44from .account_permissions_pb2_grpc import * 45from .account_resources_pb2 import * 46from .account_resources_pb2_grpc import * 47from .account_resources_history_pb2 import * 48from .account_resources_history_pb2_grpc import * 49from .accounts_pb2 import * 50from .accounts_pb2_grpc import * 51from .accounts_history_pb2 import * 52from .accounts_history_pb2_grpc import * 53from .activities_pb2 import * 54from .activities_pb2_grpc import * 55from .approval_workflow_approvers_pb2 import * 56from .approval_workflow_approvers_pb2_grpc import * 57from .approval_workflow_approvers_history_pb2 import * 58from .approval_workflow_approvers_history_pb2_grpc import * 59from .approval_workflow_steps_pb2 import * 60from .approval_workflow_steps_pb2_grpc import * 61from .approval_workflow_steps_history_pb2 import * 62from .approval_workflow_steps_history_pb2_grpc import * 63from .approval_workflows_pb2 import * 64from .approval_workflows_pb2_grpc import * 65from .approval_workflows_history_pb2 import * 66from .approval_workflows_history_pb2_grpc import * 67from .control_panel_pb2 import * 68from .control_panel_pb2_grpc import * 69from .health_checks_pb2 import * 70from .health_checks_pb2_grpc import * 71from .identity_aliases_pb2 import * 72from .identity_aliases_pb2_grpc import * 73from .identity_aliases_history_pb2 import * 74from .identity_aliases_history_pb2_grpc import * 75from .identity_sets_pb2 import * 76from .identity_sets_pb2_grpc import * 77from .identity_sets_history_pb2 import * 78from .identity_sets_history_pb2_grpc import * 79from .managed_secrets_pb2 import * 80from .managed_secrets_pb2_grpc import * 81from .nodes_pb2 import * 82from .nodes_pb2_grpc import * 83from .nodes_history_pb2 import * 84from .nodes_history_pb2_grpc import * 85from .organization_history_pb2 import * 86from .organization_history_pb2_grpc import * 87from .peering_group_nodes_pb2 import * 88from .peering_group_nodes_pb2_grpc import * 89from .peering_group_peers_pb2 import * 90from .peering_group_peers_pb2_grpc import * 91from .peering_group_resources_pb2 import * 92from .peering_group_resources_pb2_grpc import * 93from .peering_groups_pb2 import * 94from .peering_groups_pb2_grpc import * 95from .policies_pb2 import * 96from .policies_pb2_grpc import * 97from .policies_history_pb2 import * 98from .policies_history_pb2_grpc import * 99from .proxy_cluster_keys_pb2 import * 100from .proxy_cluster_keys_pb2_grpc import * 101from .queries_pb2 import * 102from .queries_pb2_grpc import * 103from .remote_identities_pb2 import * 104from .remote_identities_pb2_grpc import * 105from .remote_identities_history_pb2 import * 106from .remote_identities_history_pb2_grpc import * 107from .remote_identity_groups_pb2 import * 108from .remote_identity_groups_pb2_grpc import * 109from .remote_identity_groups_history_pb2 import * 110from .remote_identity_groups_history_pb2_grpc import * 111from .replays_pb2 import * 112from .replays_pb2_grpc import * 113from .resources_pb2 import * 114from .resources_pb2_grpc import * 115from .resources_history_pb2 import * 116from .resources_history_pb2_grpc import * 117from .role_resources_pb2 import * 118from .role_resources_pb2_grpc import * 119from .role_resources_history_pb2 import * 120from .role_resources_history_pb2_grpc import * 121from .roles_pb2 import * 122from .roles_pb2_grpc import * 123from .roles_history_pb2 import * 124from .roles_history_pb2_grpc import * 125from .secret_engine_policy_pb2 import * 126from .secret_engine_policy_pb2_grpc import * 127from .secret_engine_types_pb2 import * 128from .secret_engine_types_pb2_grpc import * 129from .secret_store_types_pb2 import * 130from .secret_store_types_pb2_grpc import * 131from .secret_stores_pb2 import * 132from .secret_stores_pb2_grpc import * 133from .secret_engines_pb2 import * 134from .secret_engines_pb2_grpc import * 135from .secret_store_healths_pb2 import * 136from .secret_store_healths_pb2_grpc import * 137from .secret_stores_history_pb2 import * 138from .secret_stores_history_pb2_grpc import * 139from .workflow_approvers_pb2 import * 140from .workflow_approvers_pb2_grpc import * 141from .workflow_approvers_history_pb2 import * 142from .workflow_approvers_history_pb2_grpc import * 143from .workflow_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 HealthChecks: 2185 ''' 2186 HealthChecks lists the last healthcheck between each node and resource. 2187 Note the unconventional capitalization here is to prevent having a collision with GRPC 2188 See `strongdm.models.Healthcheck`. 2189 ''' 2190 def __init__(self, channel, client): 2191 self.parent = client 2192 self.stub = HealthChecksStub(channel) 2193 2194 def list(self, filter, *args, timeout=None): 2195 ''' 2196 List gets a list of Healthchecks matching a given set of criteria. 2197 ''' 2198 deadline = None if timeout is None else time.time() + timeout 2199 req = HealthcheckListRequest() 2200 req.meta.CopyFrom(ListRequestMetadata()) 2201 if self.parent.page_limit > 0: 2202 req.meta.limit = self.parent.page_limit 2203 if self.parent.snapshot_datetime is not None: 2204 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2205 2206 req.filter = plumbing.quote_filter_args(filter, *args) 2207 2208 def generator(svc, req): 2209 tries = 0 2210 while True: 2211 t = None if deadline is None else deadline - time.time() 2212 try: 2213 plumbing_response = svc.stub.List( 2214 req, 2215 metadata=svc.parent.get_metadata( 2216 'HealthChecks.List', req), 2217 timeout=t) 2218 except Exception as e: 2219 if self.parent.shouldRetry(tries, e, deadline): 2220 tries += 1 2221 time.sleep( 2222 self.parent.exponentialBackoff(tries, deadline)) 2223 continue 2224 raise plumbing.convert_error_to_porcelain(e) from e 2225 tries = 0 2226 for plumbing_item in plumbing_response.healthchecks: 2227 yield plumbing.convert_healthcheck_to_porcelain( 2228 plumbing_item) 2229 if plumbing_response.meta.next_cursor == '': 2230 break 2231 req.meta.cursor = plumbing_response.meta.next_cursor 2232 2233 return generator(self, req) 2234 2235 2236class IdentityAliases: 2237 ''' 2238 IdentityAliases assign an alias to an account within an IdentitySet. 2239 The alias is used as the username when connecting to a identity supported resource. 2240 See `strongdm.models.IdentityAlias`. 2241 ''' 2242 def __init__(self, channel, client): 2243 self.parent = client 2244 self.stub = IdentityAliasesStub(channel) 2245 2246 def create(self, identity_alias, timeout=None): 2247 ''' 2248 Create registers a new IdentityAlias. 2249 ''' 2250 deadline = None if timeout is None else time.time() + timeout 2251 req = IdentityAliasCreateRequest() 2252 2253 if identity_alias is not None: 2254 req.identity_alias.CopyFrom( 2255 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2256 tries = 0 2257 plumbing_response = None 2258 while True: 2259 t = None if deadline is None else deadline - time.time() 2260 try: 2261 plumbing_response = self.stub.Create( 2262 req, 2263 metadata=self.parent.get_metadata('IdentityAliases.Create', 2264 req), 2265 timeout=t) 2266 except Exception as e: 2267 if self.parent.shouldRetry(tries, e, deadline): 2268 tries += 1 2269 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2270 continue 2271 raise plumbing.convert_error_to_porcelain(e) from e 2272 break 2273 2274 resp = models.IdentityAliasCreateResponse() 2275 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2276 plumbing_response.identity_alias) 2277 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2278 plumbing_response.meta) 2279 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2280 plumbing_response.rate_limit) 2281 return resp 2282 2283 def get(self, id, timeout=None): 2284 ''' 2285 Get reads one IdentityAlias by ID. 2286 ''' 2287 deadline = None if timeout is None else time.time() + timeout 2288 req = IdentityAliasGetRequest() 2289 if self.parent.snapshot_datetime is not None: 2290 req.meta.CopyFrom(GetRequestMetadata()) 2291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2292 2293 req.id = (id) 2294 tries = 0 2295 plumbing_response = None 2296 while True: 2297 t = None if deadline is None else deadline - time.time() 2298 try: 2299 plumbing_response = self.stub.Get( 2300 req, 2301 metadata=self.parent.get_metadata('IdentityAliases.Get', 2302 req), 2303 timeout=t) 2304 except Exception as e: 2305 if self.parent.shouldRetry(tries, e, deadline): 2306 tries += 1 2307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2308 continue 2309 raise plumbing.convert_error_to_porcelain(e) from e 2310 break 2311 2312 resp = models.IdentityAliasGetResponse() 2313 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2314 plumbing_response.identity_alias) 2315 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2316 plumbing_response.meta) 2317 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2318 plumbing_response.rate_limit) 2319 return resp 2320 2321 def update(self, identity_alias, timeout=None): 2322 ''' 2323 Update replaces all the fields of a IdentityAlias by ID. 2324 ''' 2325 deadline = None if timeout is None else time.time() + timeout 2326 req = IdentityAliasUpdateRequest() 2327 2328 if identity_alias is not None: 2329 req.identity_alias.CopyFrom( 2330 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2331 tries = 0 2332 plumbing_response = None 2333 while True: 2334 t = None if deadline is None else deadline - time.time() 2335 try: 2336 plumbing_response = self.stub.Update( 2337 req, 2338 metadata=self.parent.get_metadata('IdentityAliases.Update', 2339 req), 2340 timeout=t) 2341 except Exception as e: 2342 if self.parent.shouldRetry(tries, e, deadline): 2343 tries += 1 2344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2345 continue 2346 raise plumbing.convert_error_to_porcelain(e) from e 2347 break 2348 2349 resp = models.IdentityAliasUpdateResponse() 2350 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2351 plumbing_response.identity_alias) 2352 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2353 plumbing_response.meta) 2354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2355 plumbing_response.rate_limit) 2356 return resp 2357 2358 def delete(self, id, timeout=None): 2359 ''' 2360 Delete removes a IdentityAlias by ID. 2361 ''' 2362 deadline = None if timeout is None else time.time() + timeout 2363 req = IdentityAliasDeleteRequest() 2364 2365 req.id = (id) 2366 tries = 0 2367 plumbing_response = None 2368 while True: 2369 t = None if deadline is None else deadline - time.time() 2370 try: 2371 plumbing_response = self.stub.Delete( 2372 req, 2373 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2374 req), 2375 timeout=t) 2376 except Exception as e: 2377 if self.parent.shouldRetry(tries, e, deadline): 2378 tries += 1 2379 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2380 continue 2381 raise plumbing.convert_error_to_porcelain(e) from e 2382 break 2383 2384 resp = models.IdentityAliasDeleteResponse() 2385 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2386 plumbing_response.meta) 2387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2388 plumbing_response.rate_limit) 2389 return resp 2390 2391 def list(self, filter, *args, timeout=None): 2392 ''' 2393 List gets a list of IdentityAliases matching a given set of criteria. 2394 ''' 2395 deadline = None if timeout is None else time.time() + timeout 2396 req = IdentityAliasListRequest() 2397 req.meta.CopyFrom(ListRequestMetadata()) 2398 if self.parent.page_limit > 0: 2399 req.meta.limit = self.parent.page_limit 2400 if self.parent.snapshot_datetime is not None: 2401 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2402 2403 req.filter = plumbing.quote_filter_args(filter, *args) 2404 2405 def generator(svc, req): 2406 tries = 0 2407 while True: 2408 t = None if deadline is None else deadline - time.time() 2409 try: 2410 plumbing_response = svc.stub.List( 2411 req, 2412 metadata=svc.parent.get_metadata( 2413 'IdentityAliases.List', req), 2414 timeout=t) 2415 except Exception as e: 2416 if self.parent.shouldRetry(tries, e, deadline): 2417 tries += 1 2418 time.sleep( 2419 self.parent.exponentialBackoff(tries, deadline)) 2420 continue 2421 raise plumbing.convert_error_to_porcelain(e) from e 2422 tries = 0 2423 for plumbing_item in plumbing_response.identity_aliases: 2424 yield plumbing.convert_identity_alias_to_porcelain( 2425 plumbing_item) 2426 if plumbing_response.meta.next_cursor == '': 2427 break 2428 req.meta.cursor = plumbing_response.meta.next_cursor 2429 2430 return generator(self, req) 2431 2432 2433class SnapshotIdentityAliases: 2434 ''' 2435 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2436 service for historical queries. 2437 ''' 2438 def __init__(self, identity_aliases): 2439 self.identity_aliases = identity_aliases 2440 2441 def get(self, id, timeout=None): 2442 ''' 2443 Get reads one IdentityAlias by ID. 2444 ''' 2445 return self.identity_aliases.get(id, timeout=timeout) 2446 2447 def list(self, filter, *args, timeout=None): 2448 ''' 2449 List gets a list of IdentityAliases matching a given set of criteria. 2450 ''' 2451 return self.identity_aliases.list(filter, *args, timeout=timeout) 2452 2453 2454class IdentityAliasesHistory: 2455 ''' 2456 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2457 See `strongdm.models.IdentityAliasHistory`. 2458 ''' 2459 def __init__(self, channel, client): 2460 self.parent = client 2461 self.stub = IdentityAliasesHistoryStub(channel) 2462 2463 def list(self, filter, *args, timeout=None): 2464 ''' 2465 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2466 ''' 2467 deadline = None if timeout is None else time.time() + timeout 2468 req = IdentityAliasHistoryListRequest() 2469 req.meta.CopyFrom(ListRequestMetadata()) 2470 if self.parent.page_limit > 0: 2471 req.meta.limit = self.parent.page_limit 2472 if self.parent.snapshot_datetime is not None: 2473 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2474 2475 req.filter = plumbing.quote_filter_args(filter, *args) 2476 2477 def generator(svc, req): 2478 tries = 0 2479 while True: 2480 t = None if deadline is None else deadline - time.time() 2481 try: 2482 plumbing_response = svc.stub.List( 2483 req, 2484 metadata=svc.parent.get_metadata( 2485 'IdentityAliasesHistory.List', req), 2486 timeout=t) 2487 except Exception as e: 2488 if self.parent.shouldRetry(tries, e, deadline): 2489 tries += 1 2490 time.sleep( 2491 self.parent.exponentialBackoff(tries, deadline)) 2492 continue 2493 raise plumbing.convert_error_to_porcelain(e) from e 2494 tries = 0 2495 for plumbing_item in plumbing_response.history: 2496 yield plumbing.convert_identity_alias_history_to_porcelain( 2497 plumbing_item) 2498 if plumbing_response.meta.next_cursor == '': 2499 break 2500 req.meta.cursor = plumbing_response.meta.next_cursor 2501 2502 return generator(self, req) 2503 2504 2505class IdentitySets: 2506 ''' 2507 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2508 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2509 See `strongdm.models.IdentitySet`. 2510 ''' 2511 def __init__(self, channel, client): 2512 self.parent = client 2513 self.stub = IdentitySetsStub(channel) 2514 2515 def create(self, identity_set, timeout=None): 2516 ''' 2517 Create registers a new IdentitySet. 2518 ''' 2519 deadline = None if timeout is None else time.time() + timeout 2520 req = IdentitySetCreateRequest() 2521 2522 if identity_set is not None: 2523 req.identity_set.CopyFrom( 2524 plumbing.convert_identity_set_to_plumbing(identity_set)) 2525 tries = 0 2526 plumbing_response = None 2527 while True: 2528 t = None if deadline is None else deadline - time.time() 2529 try: 2530 plumbing_response = self.stub.Create( 2531 req, 2532 metadata=self.parent.get_metadata('IdentitySets.Create', 2533 req), 2534 timeout=t) 2535 except Exception as e: 2536 if self.parent.shouldRetry(tries, e, deadline): 2537 tries += 1 2538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2539 continue 2540 raise plumbing.convert_error_to_porcelain(e) from e 2541 break 2542 2543 resp = models.IdentitySetCreateResponse() 2544 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2545 plumbing_response.identity_set) 2546 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2547 plumbing_response.meta) 2548 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2549 plumbing_response.rate_limit) 2550 return resp 2551 2552 def get(self, id, timeout=None): 2553 ''' 2554 Get reads one IdentitySet by ID. 2555 ''' 2556 deadline = None if timeout is None else time.time() + timeout 2557 req = IdentitySetGetRequest() 2558 if self.parent.snapshot_datetime is not None: 2559 req.meta.CopyFrom(GetRequestMetadata()) 2560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2561 2562 req.id = (id) 2563 tries = 0 2564 plumbing_response = None 2565 while True: 2566 t = None if deadline is None else deadline - time.time() 2567 try: 2568 plumbing_response = self.stub.Get( 2569 req, 2570 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2571 timeout=t) 2572 except Exception as e: 2573 if self.parent.shouldRetry(tries, e, deadline): 2574 tries += 1 2575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2576 continue 2577 raise plumbing.convert_error_to_porcelain(e) from e 2578 break 2579 2580 resp = models.IdentitySetGetResponse() 2581 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2582 plumbing_response.identity_set) 2583 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2584 plumbing_response.meta) 2585 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2586 plumbing_response.rate_limit) 2587 return resp 2588 2589 def update(self, identity_set, timeout=None): 2590 ''' 2591 Update replaces all the fields of a IdentitySet by ID. 2592 ''' 2593 deadline = None if timeout is None else time.time() + timeout 2594 req = IdentitySetUpdateRequest() 2595 2596 if identity_set is not None: 2597 req.identity_set.CopyFrom( 2598 plumbing.convert_identity_set_to_plumbing(identity_set)) 2599 tries = 0 2600 plumbing_response = None 2601 while True: 2602 t = None if deadline is None else deadline - time.time() 2603 try: 2604 plumbing_response = self.stub.Update( 2605 req, 2606 metadata=self.parent.get_metadata('IdentitySets.Update', 2607 req), 2608 timeout=t) 2609 except Exception as e: 2610 if self.parent.shouldRetry(tries, e, deadline): 2611 tries += 1 2612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2613 continue 2614 raise plumbing.convert_error_to_porcelain(e) from e 2615 break 2616 2617 resp = models.IdentitySetUpdateResponse() 2618 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2619 plumbing_response.identity_set) 2620 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2621 plumbing_response.meta) 2622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2623 plumbing_response.rate_limit) 2624 return resp 2625 2626 def delete(self, id, timeout=None): 2627 ''' 2628 Delete removes a IdentitySet by ID. 2629 ''' 2630 deadline = None if timeout is None else time.time() + timeout 2631 req = IdentitySetDeleteRequest() 2632 2633 req.id = (id) 2634 tries = 0 2635 plumbing_response = None 2636 while True: 2637 t = None if deadline is None else deadline - time.time() 2638 try: 2639 plumbing_response = self.stub.Delete( 2640 req, 2641 metadata=self.parent.get_metadata('IdentitySets.Delete', 2642 req), 2643 timeout=t) 2644 except Exception as e: 2645 if self.parent.shouldRetry(tries, e, deadline): 2646 tries += 1 2647 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2648 continue 2649 raise plumbing.convert_error_to_porcelain(e) from e 2650 break 2651 2652 resp = models.IdentitySetDeleteResponse() 2653 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2654 plumbing_response.meta) 2655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2656 plumbing_response.rate_limit) 2657 return resp 2658 2659 def list(self, filter, *args, timeout=None): 2660 ''' 2661 List gets a list of IdentitySets matching a given set of criteria. 2662 ''' 2663 deadline = None if timeout is None else time.time() + timeout 2664 req = IdentitySetListRequest() 2665 req.meta.CopyFrom(ListRequestMetadata()) 2666 if self.parent.page_limit > 0: 2667 req.meta.limit = self.parent.page_limit 2668 if self.parent.snapshot_datetime is not None: 2669 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2670 2671 req.filter = plumbing.quote_filter_args(filter, *args) 2672 2673 def generator(svc, req): 2674 tries = 0 2675 while True: 2676 t = None if deadline is None else deadline - time.time() 2677 try: 2678 plumbing_response = svc.stub.List( 2679 req, 2680 metadata=svc.parent.get_metadata( 2681 'IdentitySets.List', req), 2682 timeout=t) 2683 except Exception as e: 2684 if self.parent.shouldRetry(tries, e, deadline): 2685 tries += 1 2686 time.sleep( 2687 self.parent.exponentialBackoff(tries, deadline)) 2688 continue 2689 raise plumbing.convert_error_to_porcelain(e) from e 2690 tries = 0 2691 for plumbing_item in plumbing_response.identity_sets: 2692 yield plumbing.convert_identity_set_to_porcelain( 2693 plumbing_item) 2694 if plumbing_response.meta.next_cursor == '': 2695 break 2696 req.meta.cursor = plumbing_response.meta.next_cursor 2697 2698 return generator(self, req) 2699 2700 2701class SnapshotIdentitySets: 2702 ''' 2703 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2704 service for historical queries. 2705 ''' 2706 def __init__(self, identity_sets): 2707 self.identity_sets = identity_sets 2708 2709 def get(self, id, timeout=None): 2710 ''' 2711 Get reads one IdentitySet by ID. 2712 ''' 2713 return self.identity_sets.get(id, timeout=timeout) 2714 2715 def list(self, filter, *args, timeout=None): 2716 ''' 2717 List gets a list of IdentitySets matching a given set of criteria. 2718 ''' 2719 return self.identity_sets.list(filter, *args, timeout=timeout) 2720 2721 2722class IdentitySetsHistory: 2723 ''' 2724 IdentitySetsHistory records all changes to the state of a IdentitySet. 2725 See `strongdm.models.IdentitySetHistory`. 2726 ''' 2727 def __init__(self, channel, client): 2728 self.parent = client 2729 self.stub = IdentitySetsHistoryStub(channel) 2730 2731 def list(self, filter, *args, timeout=None): 2732 ''' 2733 List gets a list of IdentitySetHistory records matching a given set of criteria. 2734 ''' 2735 deadline = None if timeout is None else time.time() + timeout 2736 req = IdentitySetHistoryListRequest() 2737 req.meta.CopyFrom(ListRequestMetadata()) 2738 if self.parent.page_limit > 0: 2739 req.meta.limit = self.parent.page_limit 2740 if self.parent.snapshot_datetime is not None: 2741 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2742 2743 req.filter = plumbing.quote_filter_args(filter, *args) 2744 2745 def generator(svc, req): 2746 tries = 0 2747 while True: 2748 t = None if deadline is None else deadline - time.time() 2749 try: 2750 plumbing_response = svc.stub.List( 2751 req, 2752 metadata=svc.parent.get_metadata( 2753 'IdentitySetsHistory.List', req), 2754 timeout=t) 2755 except Exception as e: 2756 if self.parent.shouldRetry(tries, e, deadline): 2757 tries += 1 2758 time.sleep( 2759 self.parent.exponentialBackoff(tries, deadline)) 2760 continue 2761 raise plumbing.convert_error_to_porcelain(e) from e 2762 tries = 0 2763 for plumbing_item in plumbing_response.history: 2764 yield plumbing.convert_identity_set_history_to_porcelain( 2765 plumbing_item) 2766 if plumbing_response.meta.next_cursor == '': 2767 break 2768 req.meta.cursor = plumbing_response.meta.next_cursor 2769 2770 return generator(self, req) 2771 2772 2773class ManagedSecrets: 2774 ''' 2775 ManagedSecret is a private vertical for creating, reading, updating, 2776 deleting, listing and rotating the managed secrets in the secrets engines as 2777 an authenticated user. 2778 See `strongdm.models.ManagedSecret`. 2779 ''' 2780 def __init__(self, channel, client): 2781 self.parent = client 2782 self.stub = ManagedSecretsStub(channel) 2783 2784 def list(self, filter, *args, timeout=None): 2785 ''' 2786 List returns Managed Secrets from a Secret Engine. 2787 ''' 2788 deadline = None if timeout is None else time.time() + timeout 2789 req = ManagedSecretListRequest() 2790 req.meta.CopyFrom(ListRequestMetadata()) 2791 if self.parent.page_limit > 0: 2792 req.meta.limit = self.parent.page_limit 2793 if self.parent.snapshot_datetime is not None: 2794 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2795 2796 req.filter = plumbing.quote_filter_args(filter, *args) 2797 2798 def generator(svc, req): 2799 tries = 0 2800 while True: 2801 t = None if deadline is None else deadline - time.time() 2802 try: 2803 plumbing_response = svc.stub.List( 2804 req, 2805 metadata=svc.parent.get_metadata( 2806 'ManagedSecrets.List', req), 2807 timeout=t) 2808 except Exception as e: 2809 if self.parent.shouldRetry(tries, e, deadline): 2810 tries += 1 2811 time.sleep( 2812 self.parent.exponentialBackoff(tries, deadline)) 2813 continue 2814 raise plumbing.convert_error_to_porcelain(e) from e 2815 tries = 0 2816 for plumbing_item in plumbing_response.managed_secrets: 2817 yield plumbing.convert_managed_secret_to_porcelain( 2818 plumbing_item) 2819 if plumbing_response.meta.next_cursor == '': 2820 break 2821 req.meta.cursor = plumbing_response.meta.next_cursor 2822 2823 return generator(self, req) 2824 2825 def list_by_actor(self, filter, *args, timeout=None): 2826 ''' 2827 List returns Managed Secrets for an Actor from a Secret Engine. 2828 ''' 2829 deadline = None if timeout is None else time.time() + timeout 2830 req = ManagedSecretListRequest() 2831 req.meta.CopyFrom(ListRequestMetadata()) 2832 if self.parent.page_limit > 0: 2833 req.meta.limit = self.parent.page_limit 2834 if self.parent.snapshot_datetime is not None: 2835 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2836 2837 req.filter = plumbing.quote_filter_args(filter, *args) 2838 2839 def generator(svc, req): 2840 tries = 0 2841 while True: 2842 t = None if deadline is None else deadline - time.time() 2843 try: 2844 plumbing_response = svc.stub.ListByActor( 2845 req, 2846 metadata=svc.parent.get_metadata( 2847 'ManagedSecrets.ListByActor', req), 2848 timeout=t) 2849 except Exception as e: 2850 if self.parent.shouldRetry(tries, e, deadline): 2851 tries += 1 2852 time.sleep( 2853 self.parent.exponentialBackoff(tries, deadline)) 2854 continue 2855 raise plumbing.convert_error_to_porcelain(e) from e 2856 tries = 0 2857 for plumbing_item in plumbing_response.managed_secrets: 2858 yield plumbing.convert_managed_secret_to_porcelain( 2859 plumbing_item) 2860 if plumbing_response.meta.next_cursor == '': 2861 break 2862 req.meta.cursor = plumbing_response.meta.next_cursor 2863 2864 return generator(self, req) 2865 2866 def create(self, managed_secret, timeout=None): 2867 ''' 2868 Create creates a Managed Secret 2869 ''' 2870 deadline = None if timeout is None else time.time() + timeout 2871 req = ManagedSecretCreateRequest() 2872 2873 if managed_secret is not None: 2874 req.managed_secret.CopyFrom( 2875 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2876 tries = 0 2877 plumbing_response = None 2878 while True: 2879 t = None if deadline is None else deadline - time.time() 2880 try: 2881 plumbing_response = self.stub.Create( 2882 req, 2883 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2884 req), 2885 timeout=t) 2886 except Exception as e: 2887 if self.parent.shouldRetry(tries, e, deadline): 2888 tries += 1 2889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2890 continue 2891 raise plumbing.convert_error_to_porcelain(e) from e 2892 break 2893 2894 resp = models.ManagedSecretCreateResponse() 2895 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2896 plumbing_response.managed_secret) 2897 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2898 plumbing_response.meta) 2899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2900 plumbing_response.rate_limit) 2901 return resp 2902 2903 def update(self, managed_secret, timeout=None): 2904 ''' 2905 Update updates a Managed Secret 2906 ''' 2907 deadline = None if timeout is None else time.time() + timeout 2908 req = ManagedSecretUpdateRequest() 2909 2910 if managed_secret is not None: 2911 req.managed_secret.CopyFrom( 2912 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2913 tries = 0 2914 plumbing_response = None 2915 while True: 2916 t = None if deadline is None else deadline - time.time() 2917 try: 2918 plumbing_response = self.stub.Update( 2919 req, 2920 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2921 req), 2922 timeout=t) 2923 except Exception as e: 2924 if self.parent.shouldRetry(tries, e, deadline): 2925 tries += 1 2926 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2927 continue 2928 raise plumbing.convert_error_to_porcelain(e) from e 2929 break 2930 2931 resp = models.ManagedSecretUpdateResponse() 2932 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2933 plumbing_response.managed_secret) 2934 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2935 plumbing_response.meta) 2936 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2937 plumbing_response.rate_limit) 2938 return resp 2939 2940 def rotate(self, id, timeout=None): 2941 ''' 2942 Rotate forces rotation of Managed Secret 2943 ''' 2944 deadline = None if timeout is None else time.time() + timeout 2945 req = ManagedSecretRotateRequest() 2946 2947 req.id = (id) 2948 tries = 0 2949 plumbing_response = None 2950 while True: 2951 t = None if deadline is None else deadline - time.time() 2952 try: 2953 plumbing_response = self.stub.Rotate( 2954 req, 2955 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2956 req), 2957 timeout=t) 2958 except Exception as e: 2959 if self.parent.shouldRetry(tries, e, deadline): 2960 tries += 1 2961 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2962 continue 2963 raise plumbing.convert_error_to_porcelain(e) from e 2964 break 2965 2966 resp = models.ManagedSecretRotateResponse() 2967 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2968 plumbing_response.meta) 2969 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2970 plumbing_response.rate_limit) 2971 return resp 2972 2973 def delete(self, id, timeout=None): 2974 ''' 2975 Delete deletes a Managed Secret 2976 ''' 2977 deadline = None if timeout is None else time.time() + timeout 2978 req = ManagedSecretDeleteRequest() 2979 2980 req.id = (id) 2981 tries = 0 2982 plumbing_response = None 2983 while True: 2984 t = None if deadline is None else deadline - time.time() 2985 try: 2986 plumbing_response = self.stub.Delete( 2987 req, 2988 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2989 req), 2990 timeout=t) 2991 except Exception as e: 2992 if self.parent.shouldRetry(tries, e, deadline): 2993 tries += 1 2994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2995 continue 2996 raise plumbing.convert_error_to_porcelain(e) from e 2997 break 2998 2999 resp = models.ManagedSecretDeleteResponse() 3000 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3001 plumbing_response.rate_limit) 3002 return resp 3003 3004 def get(self, id, timeout=None): 3005 ''' 3006 Get gets details of a Managed Secret without sensitive data 3007 ''' 3008 deadline = None if timeout is None else time.time() + timeout 3009 req = ManagedSecretGetRequest() 3010 if self.parent.snapshot_datetime is not None: 3011 req.meta.CopyFrom(GetRequestMetadata()) 3012 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3013 3014 req.id = (id) 3015 tries = 0 3016 plumbing_response = None 3017 while True: 3018 t = None if deadline is None else deadline - time.time() 3019 try: 3020 plumbing_response = self.stub.Get( 3021 req, 3022 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3023 req), 3024 timeout=t) 3025 except Exception as e: 3026 if self.parent.shouldRetry(tries, e, deadline): 3027 tries += 1 3028 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3029 continue 3030 raise plumbing.convert_error_to_porcelain(e) from e 3031 break 3032 3033 resp = models.ManagedSecretGetResponse() 3034 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3035 plumbing_response.managed_secret) 3036 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3037 plumbing_response.meta) 3038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3039 plumbing_response.rate_limit) 3040 return resp 3041 3042 def retrieve(self, id, public_key, timeout=None): 3043 ''' 3044 Retrieve returns Managed Secret with sensitive data 3045 ''' 3046 deadline = None if timeout is None else time.time() + timeout 3047 req = ManagedSecretRetrieveRequest() 3048 3049 req.id = (id) 3050 req.public_key = (public_key) 3051 tries = 0 3052 plumbing_response = None 3053 while True: 3054 t = None if deadline is None else deadline - time.time() 3055 try: 3056 plumbing_response = self.stub.Retrieve( 3057 req, 3058 metadata=self.parent.get_metadata( 3059 'ManagedSecrets.Retrieve', req), 3060 timeout=t) 3061 except Exception as e: 3062 if self.parent.shouldRetry(tries, e, deadline): 3063 tries += 1 3064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3065 continue 3066 raise plumbing.convert_error_to_porcelain(e) from e 3067 break 3068 3069 resp = models.ManagedSecretRetrieveResponse() 3070 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3071 plumbing_response.managed_secret) 3072 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3073 plumbing_response.meta) 3074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3075 plumbing_response.rate_limit) 3076 return resp 3077 3078 def validate(self, id, timeout=None): 3079 ''' 3080 Validate returns the result of testing the stored credential against the 3081 secret engine. 3082 ''' 3083 deadline = None if timeout is None else time.time() + timeout 3084 req = ManagedSecretValidateRequest() 3085 3086 req.id = (id) 3087 tries = 0 3088 plumbing_response = None 3089 while True: 3090 t = None if deadline is None else deadline - time.time() 3091 try: 3092 plumbing_response = self.stub.Validate( 3093 req, 3094 metadata=self.parent.get_metadata( 3095 'ManagedSecrets.Validate', req), 3096 timeout=t) 3097 except Exception as e: 3098 if self.parent.shouldRetry(tries, e, deadline): 3099 tries += 1 3100 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3101 continue 3102 raise plumbing.convert_error_to_porcelain(e) from e 3103 break 3104 3105 resp = models.ManagedSecretValidateResponse() 3106 resp.invalid_info = (plumbing_response.invalid_info) 3107 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3108 plumbing_response.meta) 3109 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3110 plumbing_response.rate_limit) 3111 resp.valid = (plumbing_response.valid) 3112 return resp 3113 3114 def logs(self, filter, *args, timeout=None): 3115 ''' 3116 Logs returns the audit records for the managed secret. This may be replaced 3117 in the future. 3118 ''' 3119 deadline = None if timeout is None else time.time() + timeout 3120 req = ManagedSecretLogsRequest() 3121 req.meta.CopyFrom(ListRequestMetadata()) 3122 if self.parent.page_limit > 0: 3123 req.meta.limit = self.parent.page_limit 3124 if self.parent.snapshot_datetime is not None: 3125 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3126 3127 req.filter = plumbing.quote_filter_args(filter, *args) 3128 3129 def generator(svc, req): 3130 tries = 0 3131 while True: 3132 t = None if deadline is None else deadline - time.time() 3133 try: 3134 plumbing_response = svc.stub.Logs( 3135 req, 3136 metadata=svc.parent.get_metadata( 3137 'ManagedSecrets.Logs', req), 3138 timeout=t) 3139 except Exception as e: 3140 if self.parent.shouldRetry(tries, e, deadline): 3141 tries += 1 3142 time.sleep( 3143 self.parent.exponentialBackoff(tries, deadline)) 3144 continue 3145 raise plumbing.convert_error_to_porcelain(e) from e 3146 tries = 0 3147 for plumbing_item in plumbing_response.managed_secret_logs: 3148 yield plumbing.convert_managed_secret_log_to_porcelain( 3149 plumbing_item) 3150 if plumbing_response.meta.next_cursor == '': 3151 break 3152 req.meta.cursor = plumbing_response.meta.next_cursor 3153 3154 return generator(self, req) 3155 3156 3157class Nodes: 3158 ''' 3159 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3160 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3161 - **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. 3162 See: 3163 `strongdm.models.Gateway` 3164 `strongdm.models.ProxyCluster` 3165 `strongdm.models.Relay` 3166 ''' 3167 def __init__(self, channel, client): 3168 self.parent = client 3169 self.stub = NodesStub(channel) 3170 3171 def create(self, node, timeout=None): 3172 ''' 3173 Create registers a new Node. 3174 ''' 3175 deadline = None if timeout is None else time.time() + timeout 3176 req = NodeCreateRequest() 3177 3178 if node is not None: 3179 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3180 tries = 0 3181 plumbing_response = None 3182 while True: 3183 t = None if deadline is None else deadline - time.time() 3184 try: 3185 plumbing_response = self.stub.Create( 3186 req, 3187 metadata=self.parent.get_metadata('Nodes.Create', req), 3188 timeout=t) 3189 except Exception as e: 3190 if self.parent.shouldRetry(tries, e, deadline): 3191 tries += 1 3192 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3193 continue 3194 raise plumbing.convert_error_to_porcelain(e) from e 3195 break 3196 3197 resp = models.NodeCreateResponse() 3198 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3199 plumbing_response.meta) 3200 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3201 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3202 plumbing_response.rate_limit) 3203 resp.token = (plumbing_response.token) 3204 return resp 3205 3206 def get(self, id, timeout=None): 3207 ''' 3208 Get reads one Node by ID. 3209 ''' 3210 deadline = None if timeout is None else time.time() + timeout 3211 req = NodeGetRequest() 3212 if self.parent.snapshot_datetime is not None: 3213 req.meta.CopyFrom(GetRequestMetadata()) 3214 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3215 3216 req.id = (id) 3217 tries = 0 3218 plumbing_response = None 3219 while True: 3220 t = None if deadline is None else deadline - time.time() 3221 try: 3222 plumbing_response = self.stub.Get( 3223 req, 3224 metadata=self.parent.get_metadata('Nodes.Get', req), 3225 timeout=t) 3226 except Exception as e: 3227 if self.parent.shouldRetry(tries, e, deadline): 3228 tries += 1 3229 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3230 continue 3231 raise plumbing.convert_error_to_porcelain(e) from e 3232 break 3233 3234 resp = models.NodeGetResponse() 3235 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3236 plumbing_response.meta) 3237 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3238 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3239 plumbing_response.rate_limit) 3240 return resp 3241 3242 def update(self, node, timeout=None): 3243 ''' 3244 Update replaces all the fields of a Node by ID. 3245 ''' 3246 deadline = None if timeout is None else time.time() + timeout 3247 req = NodeUpdateRequest() 3248 3249 if node is not None: 3250 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3251 tries = 0 3252 plumbing_response = None 3253 while True: 3254 t = None if deadline is None else deadline - time.time() 3255 try: 3256 plumbing_response = self.stub.Update( 3257 req, 3258 metadata=self.parent.get_metadata('Nodes.Update', req), 3259 timeout=t) 3260 except Exception as e: 3261 if self.parent.shouldRetry(tries, e, deadline): 3262 tries += 1 3263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3264 continue 3265 raise plumbing.convert_error_to_porcelain(e) from e 3266 break 3267 3268 resp = models.NodeUpdateResponse() 3269 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3270 plumbing_response.meta) 3271 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3273 plumbing_response.rate_limit) 3274 return resp 3275 3276 def delete(self, id, timeout=None): 3277 ''' 3278 Delete removes a Node by ID. 3279 ''' 3280 deadline = None if timeout is None else time.time() + timeout 3281 req = NodeDeleteRequest() 3282 3283 req.id = (id) 3284 tries = 0 3285 plumbing_response = None 3286 while True: 3287 t = None if deadline is None else deadline - time.time() 3288 try: 3289 plumbing_response = self.stub.Delete( 3290 req, 3291 metadata=self.parent.get_metadata('Nodes.Delete', req), 3292 timeout=t) 3293 except Exception as e: 3294 if self.parent.shouldRetry(tries, e, deadline): 3295 tries += 1 3296 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3297 continue 3298 raise plumbing.convert_error_to_porcelain(e) from e 3299 break 3300 3301 resp = models.NodeDeleteResponse() 3302 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3303 plumbing_response.meta) 3304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3305 plumbing_response.rate_limit) 3306 return resp 3307 3308 def list(self, filter, *args, timeout=None): 3309 ''' 3310 List gets a list of Nodes matching a given set of criteria. 3311 ''' 3312 deadline = None if timeout is None else time.time() + timeout 3313 req = NodeListRequest() 3314 req.meta.CopyFrom(ListRequestMetadata()) 3315 if self.parent.page_limit > 0: 3316 req.meta.limit = self.parent.page_limit 3317 if self.parent.snapshot_datetime is not None: 3318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3319 3320 req.filter = plumbing.quote_filter_args(filter, *args) 3321 3322 def generator(svc, req): 3323 tries = 0 3324 while True: 3325 t = None if deadline is None else deadline - time.time() 3326 try: 3327 plumbing_response = svc.stub.List( 3328 req, 3329 metadata=svc.parent.get_metadata('Nodes.List', req), 3330 timeout=t) 3331 except Exception as e: 3332 if self.parent.shouldRetry(tries, e, deadline): 3333 tries += 1 3334 time.sleep( 3335 self.parent.exponentialBackoff(tries, deadline)) 3336 continue 3337 raise plumbing.convert_error_to_porcelain(e) from e 3338 tries = 0 3339 for plumbing_item in plumbing_response.nodes: 3340 yield plumbing.convert_node_to_porcelain(plumbing_item) 3341 if plumbing_response.meta.next_cursor == '': 3342 break 3343 req.meta.cursor = plumbing_response.meta.next_cursor 3344 3345 return generator(self, req) 3346 3347 3348class SnapshotNodes: 3349 ''' 3350 SnapshotNodes exposes the read only methods of the Nodes 3351 service for historical queries. 3352 ''' 3353 def __init__(self, nodes): 3354 self.nodes = nodes 3355 3356 def get(self, id, timeout=None): 3357 ''' 3358 Get reads one Node by ID. 3359 ''' 3360 return self.nodes.get(id, timeout=timeout) 3361 3362 def list(self, filter, *args, timeout=None): 3363 ''' 3364 List gets a list of Nodes matching a given set of criteria. 3365 ''' 3366 return self.nodes.list(filter, *args, timeout=timeout) 3367 3368 3369class NodesHistory: 3370 ''' 3371 NodesHistory records all changes to the state of a Node. 3372 See `strongdm.models.NodeHistory`. 3373 ''' 3374 def __init__(self, channel, client): 3375 self.parent = client 3376 self.stub = NodesHistoryStub(channel) 3377 3378 def list(self, filter, *args, timeout=None): 3379 ''' 3380 List gets a list of NodeHistory records matching a given set of criteria. 3381 ''' 3382 deadline = None if timeout is None else time.time() + timeout 3383 req = NodeHistoryListRequest() 3384 req.meta.CopyFrom(ListRequestMetadata()) 3385 if self.parent.page_limit > 0: 3386 req.meta.limit = self.parent.page_limit 3387 if self.parent.snapshot_datetime is not None: 3388 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3389 3390 req.filter = plumbing.quote_filter_args(filter, *args) 3391 3392 def generator(svc, req): 3393 tries = 0 3394 while True: 3395 t = None if deadline is None else deadline - time.time() 3396 try: 3397 plumbing_response = svc.stub.List( 3398 req, 3399 metadata=svc.parent.get_metadata( 3400 'NodesHistory.List', req), 3401 timeout=t) 3402 except Exception as e: 3403 if self.parent.shouldRetry(tries, e, deadline): 3404 tries += 1 3405 time.sleep( 3406 self.parent.exponentialBackoff(tries, deadline)) 3407 continue 3408 raise plumbing.convert_error_to_porcelain(e) from e 3409 tries = 0 3410 for plumbing_item in plumbing_response.history: 3411 yield plumbing.convert_node_history_to_porcelain( 3412 plumbing_item) 3413 if plumbing_response.meta.next_cursor == '': 3414 break 3415 req.meta.cursor = plumbing_response.meta.next_cursor 3416 3417 return generator(self, req) 3418 3419 3420class OrganizationHistory: 3421 ''' 3422 OrganizationHistory records all changes to the state of an Organization. 3423 See `strongdm.models.OrganizationHistoryRecord`. 3424 ''' 3425 def __init__(self, channel, client): 3426 self.parent = client 3427 self.stub = OrganizationHistoryStub(channel) 3428 3429 def list(self, filter, *args, timeout=None): 3430 ''' 3431 List gets a list of OrganizationHistory records matching a given set of criteria. 3432 ''' 3433 deadline = None if timeout is None else time.time() + timeout 3434 req = OrganizationHistoryListRequest() 3435 req.meta.CopyFrom(ListRequestMetadata()) 3436 if self.parent.page_limit > 0: 3437 req.meta.limit = self.parent.page_limit 3438 if self.parent.snapshot_datetime is not None: 3439 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3440 3441 req.filter = plumbing.quote_filter_args(filter, *args) 3442 3443 def generator(svc, req): 3444 tries = 0 3445 while True: 3446 t = None if deadline is None else deadline - time.time() 3447 try: 3448 plumbing_response = svc.stub.List( 3449 req, 3450 metadata=svc.parent.get_metadata( 3451 'OrganizationHistory.List', req), 3452 timeout=t) 3453 except Exception as e: 3454 if self.parent.shouldRetry(tries, e, deadline): 3455 tries += 1 3456 time.sleep( 3457 self.parent.exponentialBackoff(tries, deadline)) 3458 continue 3459 raise plumbing.convert_error_to_porcelain(e) from e 3460 tries = 0 3461 for plumbing_item in plumbing_response.history: 3462 yield plumbing.convert_organization_history_record_to_porcelain( 3463 plumbing_item) 3464 if plumbing_response.meta.next_cursor == '': 3465 break 3466 req.meta.cursor = plumbing_response.meta.next_cursor 3467 3468 return generator(self, req) 3469 3470 3471class PeeringGroupNodes: 3472 ''' 3473 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3474 See `strongdm.models.PeeringGroupNode`. 3475 ''' 3476 def __init__(self, channel, client): 3477 self.parent = client 3478 self.stub = PeeringGroupNodesStub(channel) 3479 3480 def create(self, peering_group_node, timeout=None): 3481 ''' 3482 Create attaches a Node to a PeeringGroup 3483 ''' 3484 deadline = None if timeout is None else time.time() + timeout 3485 req = PeeringGroupNodeCreateRequest() 3486 3487 if peering_group_node is not None: 3488 req.peering_group_node.CopyFrom( 3489 plumbing.convert_peering_group_node_to_plumbing( 3490 peering_group_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.Create( 3497 req, 3498 metadata=self.parent.get_metadata( 3499 'PeeringGroupNodes.Create', req), 3500 timeout=t) 3501 except Exception as e: 3502 if self.parent.shouldRetry(tries, e, deadline): 3503 tries += 1 3504 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3505 continue 3506 raise plumbing.convert_error_to_porcelain(e) from e 3507 break 3508 3509 resp = models.PeeringGroupNodeCreateResponse() 3510 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3511 plumbing_response.meta) 3512 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3513 plumbing_response.peering_group_node) 3514 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3515 plumbing_response.rate_limit) 3516 return resp 3517 3518 def delete(self, id, timeout=None): 3519 ''' 3520 Delete detaches a Node to a PeeringGroup. 3521 ''' 3522 deadline = None if timeout is None else time.time() + timeout 3523 req = PeeringGroupNodeDeleteRequest() 3524 3525 req.id = (id) 3526 tries = 0 3527 plumbing_response = None 3528 while True: 3529 t = None if deadline is None else deadline - time.time() 3530 try: 3531 plumbing_response = self.stub.Delete( 3532 req, 3533 metadata=self.parent.get_metadata( 3534 'PeeringGroupNodes.Delete', req), 3535 timeout=t) 3536 except Exception as e: 3537 if self.parent.shouldRetry(tries, e, deadline): 3538 tries += 1 3539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3540 continue 3541 raise plumbing.convert_error_to_porcelain(e) from e 3542 break 3543 3544 resp = models.PeeringGroupNodeDeleteResponse() 3545 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3546 plumbing_response.meta) 3547 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3548 plumbing_response.rate_limit) 3549 return resp 3550 3551 def get(self, id, timeout=None): 3552 ''' 3553 Get reads the information of one peering group to node attachment. 3554 ''' 3555 deadline = None if timeout is None else time.time() + timeout 3556 req = PeeringGroupNodeGetRequest() 3557 if self.parent.snapshot_datetime is not None: 3558 req.meta.CopyFrom(GetRequestMetadata()) 3559 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3560 3561 req.id = (id) 3562 tries = 0 3563 plumbing_response = None 3564 while True: 3565 t = None if deadline is None else deadline - time.time() 3566 try: 3567 plumbing_response = self.stub.Get( 3568 req, 3569 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3570 req), 3571 timeout=t) 3572 except Exception as e: 3573 if self.parent.shouldRetry(tries, e, deadline): 3574 tries += 1 3575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3576 continue 3577 raise plumbing.convert_error_to_porcelain(e) from e 3578 break 3579 3580 resp = models.PeeringGroupNodeGetResponse() 3581 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3582 plumbing_response.meta) 3583 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3584 plumbing_response.peering_group_node) 3585 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3586 plumbing_response.rate_limit) 3587 return resp 3588 3589 def list(self, filter, *args, timeout=None): 3590 ''' 3591 List gets a list of peering group node attachments. 3592 ''' 3593 deadline = None if timeout is None else time.time() + timeout 3594 req = PeeringGroupNodeListRequest() 3595 req.meta.CopyFrom(ListRequestMetadata()) 3596 if self.parent.page_limit > 0: 3597 req.meta.limit = self.parent.page_limit 3598 if self.parent.snapshot_datetime is not None: 3599 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3600 3601 req.filter = plumbing.quote_filter_args(filter, *args) 3602 3603 def generator(svc, req): 3604 tries = 0 3605 while True: 3606 t = None if deadline is None else deadline - time.time() 3607 try: 3608 plumbing_response = svc.stub.List( 3609 req, 3610 metadata=svc.parent.get_metadata( 3611 'PeeringGroupNodes.List', req), 3612 timeout=t) 3613 except Exception as e: 3614 if self.parent.shouldRetry(tries, e, deadline): 3615 tries += 1 3616 time.sleep( 3617 self.parent.exponentialBackoff(tries, deadline)) 3618 continue 3619 raise plumbing.convert_error_to_porcelain(e) from e 3620 tries = 0 3621 for plumbing_item in plumbing_response.peering_group_nodes: 3622 yield plumbing.convert_peering_group_node_to_porcelain( 3623 plumbing_item) 3624 if plumbing_response.meta.next_cursor == '': 3625 break 3626 req.meta.cursor = plumbing_response.meta.next_cursor 3627 3628 return generator(self, req) 3629 3630 3631class PeeringGroupPeers: 3632 ''' 3633 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3634 See `strongdm.models.PeeringGroupPeer`. 3635 ''' 3636 def __init__(self, channel, client): 3637 self.parent = client 3638 self.stub = PeeringGroupPeersStub(channel) 3639 3640 def create(self, peering_group_peer, timeout=None): 3641 ''' 3642 Create links two peering groups. 3643 ''' 3644 deadline = None if timeout is None else time.time() + timeout 3645 req = PeeringGroupPeerCreateRequest() 3646 3647 if peering_group_peer is not None: 3648 req.peering_group_peer.CopyFrom( 3649 plumbing.convert_peering_group_peer_to_plumbing( 3650 peering_group_peer)) 3651 tries = 0 3652 plumbing_response = None 3653 while True: 3654 t = None if deadline is None else deadline - time.time() 3655 try: 3656 plumbing_response = self.stub.Create( 3657 req, 3658 metadata=self.parent.get_metadata( 3659 'PeeringGroupPeers.Create', req), 3660 timeout=t) 3661 except Exception as e: 3662 if self.parent.shouldRetry(tries, e, deadline): 3663 tries += 1 3664 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3665 continue 3666 raise plumbing.convert_error_to_porcelain(e) from e 3667 break 3668 3669 resp = models.PeeringGroupPeerCreateResponse() 3670 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3671 plumbing_response.meta) 3672 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3673 plumbing_response.peering_group_peer) 3674 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3675 plumbing_response.rate_limit) 3676 return resp 3677 3678 def delete(self, id, timeout=None): 3679 ''' 3680 Delete unlinks two peering groups. 3681 ''' 3682 deadline = None if timeout is None else time.time() + timeout 3683 req = PeeringGroupPeerDeleteRequest() 3684 3685 req.id = (id) 3686 tries = 0 3687 plumbing_response = None 3688 while True: 3689 t = None if deadline is None else deadline - time.time() 3690 try: 3691 plumbing_response = self.stub.Delete( 3692 req, 3693 metadata=self.parent.get_metadata( 3694 'PeeringGroupPeers.Delete', req), 3695 timeout=t) 3696 except Exception as e: 3697 if self.parent.shouldRetry(tries, e, deadline): 3698 tries += 1 3699 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3700 continue 3701 raise plumbing.convert_error_to_porcelain(e) from e 3702 break 3703 3704 resp = models.PeeringGroupPeerDeleteResponse() 3705 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3706 plumbing_response.meta) 3707 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3708 plumbing_response.rate_limit) 3709 return resp 3710 3711 def get(self, id, timeout=None): 3712 ''' 3713 Get reads the information of one peering group link. 3714 ''' 3715 deadline = None if timeout is None else time.time() + timeout 3716 req = PeeringGroupPeerGetRequest() 3717 if self.parent.snapshot_datetime is not None: 3718 req.meta.CopyFrom(GetRequestMetadata()) 3719 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3720 3721 req.id = (id) 3722 tries = 0 3723 plumbing_response = None 3724 while True: 3725 t = None if deadline is None else deadline - time.time() 3726 try: 3727 plumbing_response = self.stub.Get( 3728 req, 3729 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3730 req), 3731 timeout=t) 3732 except Exception as e: 3733 if self.parent.shouldRetry(tries, e, deadline): 3734 tries += 1 3735 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3736 continue 3737 raise plumbing.convert_error_to_porcelain(e) from e 3738 break 3739 3740 resp = models.PeeringGroupPeerGetResponse() 3741 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3742 plumbing_response.meta) 3743 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3744 plumbing_response.peering_group_peer) 3745 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3746 plumbing_response.rate_limit) 3747 return resp 3748 3749 def list(self, filter, *args, timeout=None): 3750 ''' 3751 List gets a list of peering group links. 3752 ''' 3753 deadline = None if timeout is None else time.time() + timeout 3754 req = PeeringGroupPeerListRequest() 3755 req.meta.CopyFrom(ListRequestMetadata()) 3756 if self.parent.page_limit > 0: 3757 req.meta.limit = self.parent.page_limit 3758 if self.parent.snapshot_datetime is not None: 3759 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3760 3761 req.filter = plumbing.quote_filter_args(filter, *args) 3762 3763 def generator(svc, req): 3764 tries = 0 3765 while True: 3766 t = None if deadline is None else deadline - time.time() 3767 try: 3768 plumbing_response = svc.stub.List( 3769 req, 3770 metadata=svc.parent.get_metadata( 3771 'PeeringGroupPeers.List', req), 3772 timeout=t) 3773 except Exception as e: 3774 if self.parent.shouldRetry(tries, e, deadline): 3775 tries += 1 3776 time.sleep( 3777 self.parent.exponentialBackoff(tries, deadline)) 3778 continue 3779 raise plumbing.convert_error_to_porcelain(e) from e 3780 tries = 0 3781 for plumbing_item in plumbing_response.peering_group_peers: 3782 yield plumbing.convert_peering_group_peer_to_porcelain( 3783 plumbing_item) 3784 if plumbing_response.meta.next_cursor == '': 3785 break 3786 req.meta.cursor = plumbing_response.meta.next_cursor 3787 3788 return generator(self, req) 3789 3790 3791class PeeringGroupResources: 3792 ''' 3793 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 3794 See `strongdm.models.PeeringGroupResource`. 3795 ''' 3796 def __init__(self, channel, client): 3797 self.parent = client 3798 self.stub = PeeringGroupResourcesStub(channel) 3799 3800 def create(self, peering_group_resource, timeout=None): 3801 ''' 3802 Create attaches a Resource to a PeeringGroup 3803 ''' 3804 deadline = None if timeout is None else time.time() + timeout 3805 req = PeeringGroupResourceCreateRequest() 3806 3807 if peering_group_resource is not None: 3808 req.peering_group_resource.CopyFrom( 3809 plumbing.convert_peering_group_resource_to_plumbing( 3810 peering_group_resource)) 3811 tries = 0 3812 plumbing_response = None 3813 while True: 3814 t = None if deadline is None else deadline - time.time() 3815 try: 3816 plumbing_response = self.stub.Create( 3817 req, 3818 metadata=self.parent.get_metadata( 3819 'PeeringGroupResources.Create', req), 3820 timeout=t) 3821 except Exception as e: 3822 if self.parent.shouldRetry(tries, e, deadline): 3823 tries += 1 3824 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3825 continue 3826 raise plumbing.convert_error_to_porcelain(e) from e 3827 break 3828 3829 resp = models.PeeringGroupResourceCreateResponse() 3830 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3831 plumbing_response.meta) 3832 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3833 plumbing_response.peering_group_resource) 3834 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3835 plumbing_response.rate_limit) 3836 return resp 3837 3838 def delete(self, id, timeout=None): 3839 ''' 3840 Delete detaches a Resource to a PeeringGroup 3841 ''' 3842 deadline = None if timeout is None else time.time() + timeout 3843 req = PeeringGroupResourceDeleteRequest() 3844 3845 req.id = (id) 3846 tries = 0 3847 plumbing_response = None 3848 while True: 3849 t = None if deadline is None else deadline - time.time() 3850 try: 3851 plumbing_response = self.stub.Delete( 3852 req, 3853 metadata=self.parent.get_metadata( 3854 'PeeringGroupResources.Delete', req), 3855 timeout=t) 3856 except Exception as e: 3857 if self.parent.shouldRetry(tries, e, deadline): 3858 tries += 1 3859 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3860 continue 3861 raise plumbing.convert_error_to_porcelain(e) from e 3862 break 3863 3864 resp = models.PeeringGroupResourceDeleteResponse() 3865 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3866 plumbing_response.meta) 3867 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3868 plumbing_response.rate_limit) 3869 return resp 3870 3871 def get(self, id, timeout=None): 3872 ''' 3873 Get reads the information of one peering group to resource attachment. 3874 ''' 3875 deadline = None if timeout is None else time.time() + timeout 3876 req = PeeringGroupResourceGetRequest() 3877 if self.parent.snapshot_datetime is not None: 3878 req.meta.CopyFrom(GetRequestMetadata()) 3879 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3880 3881 req.id = (id) 3882 tries = 0 3883 plumbing_response = None 3884 while True: 3885 t = None if deadline is None else deadline - time.time() 3886 try: 3887 plumbing_response = self.stub.Get( 3888 req, 3889 metadata=self.parent.get_metadata( 3890 'PeeringGroupResources.Get', req), 3891 timeout=t) 3892 except Exception as e: 3893 if self.parent.shouldRetry(tries, e, deadline): 3894 tries += 1 3895 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3896 continue 3897 raise plumbing.convert_error_to_porcelain(e) from e 3898 break 3899 3900 resp = models.PeeringGroupResourceGetResponse() 3901 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3902 plumbing_response.meta) 3903 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3904 plumbing_response.peering_group_resource) 3905 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3906 plumbing_response.rate_limit) 3907 return resp 3908 3909 def list(self, filter, *args, timeout=None): 3910 ''' 3911 List gets a list of peering group resource attachments. 3912 ''' 3913 deadline = None if timeout is None else time.time() + timeout 3914 req = PeeringGroupResourceListRequest() 3915 req.meta.CopyFrom(ListRequestMetadata()) 3916 if self.parent.page_limit > 0: 3917 req.meta.limit = self.parent.page_limit 3918 if self.parent.snapshot_datetime is not None: 3919 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3920 3921 req.filter = plumbing.quote_filter_args(filter, *args) 3922 3923 def generator(svc, req): 3924 tries = 0 3925 while True: 3926 t = None if deadline is None else deadline - time.time() 3927 try: 3928 plumbing_response = svc.stub.List( 3929 req, 3930 metadata=svc.parent.get_metadata( 3931 'PeeringGroupResources.List', req), 3932 timeout=t) 3933 except Exception as e: 3934 if self.parent.shouldRetry(tries, e, deadline): 3935 tries += 1 3936 time.sleep( 3937 self.parent.exponentialBackoff(tries, deadline)) 3938 continue 3939 raise plumbing.convert_error_to_porcelain(e) from e 3940 tries = 0 3941 for plumbing_item in plumbing_response.peering_group_resources: 3942 yield plumbing.convert_peering_group_resource_to_porcelain( 3943 plumbing_item) 3944 if plumbing_response.meta.next_cursor == '': 3945 break 3946 req.meta.cursor = plumbing_response.meta.next_cursor 3947 3948 return generator(self, req) 3949 3950 3951class PeeringGroups: 3952 ''' 3953 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 3954 See `strongdm.models.PeeringGroup`. 3955 ''' 3956 def __init__(self, channel, client): 3957 self.parent = client 3958 self.stub = PeeringGroupsStub(channel) 3959 3960 def create(self, peering_group, timeout=None): 3961 ''' 3962 Create registers a new PeeringGroup. 3963 ''' 3964 deadline = None if timeout is None else time.time() + timeout 3965 req = PeeringGroupCreateRequest() 3966 3967 if peering_group is not None: 3968 req.peering_group.CopyFrom( 3969 plumbing.convert_peering_group_to_plumbing(peering_group)) 3970 tries = 0 3971 plumbing_response = None 3972 while True: 3973 t = None if deadline is None else deadline - time.time() 3974 try: 3975 plumbing_response = self.stub.Create( 3976 req, 3977 metadata=self.parent.get_metadata('PeeringGroups.Create', 3978 req), 3979 timeout=t) 3980 except Exception as e: 3981 if self.parent.shouldRetry(tries, e, deadline): 3982 tries += 1 3983 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3984 continue 3985 raise plumbing.convert_error_to_porcelain(e) from e 3986 break 3987 3988 resp = models.PeeringGroupCreateResponse() 3989 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3990 plumbing_response.meta) 3991 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3992 plumbing_response.peering_group) 3993 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3994 plumbing_response.rate_limit) 3995 return resp 3996 3997 def delete(self, id, timeout=None): 3998 ''' 3999 Delete removes a PeeringGroup by ID. 4000 ''' 4001 deadline = None if timeout is None else time.time() + timeout 4002 req = PeeringGroupDeleteRequest() 4003 4004 req.id = (id) 4005 tries = 0 4006 plumbing_response = None 4007 while True: 4008 t = None if deadline is None else deadline - time.time() 4009 try: 4010 plumbing_response = self.stub.Delete( 4011 req, 4012 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4013 req), 4014 timeout=t) 4015 except Exception as e: 4016 if self.parent.shouldRetry(tries, e, deadline): 4017 tries += 1 4018 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4019 continue 4020 raise plumbing.convert_error_to_porcelain(e) from e 4021 break 4022 4023 resp = models.PeeringGroupDeleteResponse() 4024 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4025 plumbing_response.meta) 4026 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4027 plumbing_response.rate_limit) 4028 return resp 4029 4030 def get(self, id, timeout=None): 4031 ''' 4032 Get reads one PeeringGroup by ID. It will load all its dependencies. 4033 ''' 4034 deadline = None if timeout is None else time.time() + timeout 4035 req = PeeringGroupGetRequest() 4036 if self.parent.snapshot_datetime is not None: 4037 req.meta.CopyFrom(GetRequestMetadata()) 4038 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4039 4040 req.id = (id) 4041 tries = 0 4042 plumbing_response = None 4043 while True: 4044 t = None if deadline is None else deadline - time.time() 4045 try: 4046 plumbing_response = self.stub.Get( 4047 req, 4048 metadata=self.parent.get_metadata('PeeringGroups.Get', 4049 req), 4050 timeout=t) 4051 except Exception as e: 4052 if self.parent.shouldRetry(tries, e, deadline): 4053 tries += 1 4054 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4055 continue 4056 raise plumbing.convert_error_to_porcelain(e) from e 4057 break 4058 4059 resp = models.PeeringGroupGetResponse() 4060 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4061 plumbing_response.meta) 4062 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4063 plumbing_response.peering_group) 4064 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4065 plumbing_response.rate_limit) 4066 return resp 4067 4068 def list(self, filter, *args, timeout=None): 4069 ''' 4070 List gets a list of Peering Groups. 4071 ''' 4072 deadline = None if timeout is None else time.time() + timeout 4073 req = PeeringGroupListRequest() 4074 req.meta.CopyFrom(ListRequestMetadata()) 4075 if self.parent.page_limit > 0: 4076 req.meta.limit = self.parent.page_limit 4077 if self.parent.snapshot_datetime is not None: 4078 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4079 4080 req.filter = plumbing.quote_filter_args(filter, *args) 4081 4082 def generator(svc, req): 4083 tries = 0 4084 while True: 4085 t = None if deadline is None else deadline - time.time() 4086 try: 4087 plumbing_response = svc.stub.List( 4088 req, 4089 metadata=svc.parent.get_metadata( 4090 'PeeringGroups.List', req), 4091 timeout=t) 4092 except Exception as e: 4093 if self.parent.shouldRetry(tries, e, deadline): 4094 tries += 1 4095 time.sleep( 4096 self.parent.exponentialBackoff(tries, deadline)) 4097 continue 4098 raise plumbing.convert_error_to_porcelain(e) from e 4099 tries = 0 4100 for plumbing_item in plumbing_response.peering_groups: 4101 yield plumbing.convert_peering_group_to_porcelain( 4102 plumbing_item) 4103 if plumbing_response.meta.next_cursor == '': 4104 break 4105 req.meta.cursor = plumbing_response.meta.next_cursor 4106 4107 return generator(self, req) 4108 4109 4110class Policies: 4111 ''' 4112 Policies are the collection of one or more statements that enforce fine-grained access 4113 control for the users of an organization. 4114 See `strongdm.models.Policy`. 4115 ''' 4116 def __init__(self, channel, client): 4117 self.parent = client 4118 self.stub = PoliciesStub(channel) 4119 4120 def create(self, policy, timeout=None): 4121 ''' 4122 Create creates a new Policy. 4123 ''' 4124 deadline = None if timeout is None else time.time() + timeout 4125 req = PolicyCreateRequest() 4126 4127 if policy is not None: 4128 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4129 tries = 0 4130 plumbing_response = None 4131 while True: 4132 t = None if deadline is None else deadline - time.time() 4133 try: 4134 plumbing_response = self.stub.Create( 4135 req, 4136 metadata=self.parent.get_metadata('Policies.Create', req), 4137 timeout=t) 4138 except Exception as e: 4139 if self.parent.shouldRetry(tries, e, deadline): 4140 tries += 1 4141 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4142 continue 4143 raise plumbing.convert_error_to_porcelain(e) from e 4144 break 4145 4146 resp = models.PolicyCreateResponse() 4147 resp.policy = plumbing.convert_policy_to_porcelain( 4148 plumbing_response.policy) 4149 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4150 plumbing_response.rate_limit) 4151 return resp 4152 4153 def delete(self, id, timeout=None): 4154 ''' 4155 Delete removes a Policy by ID. 4156 ''' 4157 deadline = None if timeout is None else time.time() + timeout 4158 req = PolicyDeleteRequest() 4159 4160 req.id = (id) 4161 tries = 0 4162 plumbing_response = None 4163 while True: 4164 t = None if deadline is None else deadline - time.time() 4165 try: 4166 plumbing_response = self.stub.Delete( 4167 req, 4168 metadata=self.parent.get_metadata('Policies.Delete', req), 4169 timeout=t) 4170 except Exception as e: 4171 if self.parent.shouldRetry(tries, e, deadline): 4172 tries += 1 4173 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4174 continue 4175 raise plumbing.convert_error_to_porcelain(e) from e 4176 break 4177 4178 resp = models.PolicyDeleteResponse() 4179 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4180 plumbing_response.rate_limit) 4181 return resp 4182 4183 def update(self, policy, timeout=None): 4184 ''' 4185 Update replaces all the fields of a Policy by ID. 4186 ''' 4187 deadline = None if timeout is None else time.time() + timeout 4188 req = PolicyUpdateRequest() 4189 4190 if policy is not None: 4191 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4192 tries = 0 4193 plumbing_response = None 4194 while True: 4195 t = None if deadline is None else deadline - time.time() 4196 try: 4197 plumbing_response = self.stub.Update( 4198 req, 4199 metadata=self.parent.get_metadata('Policies.Update', req), 4200 timeout=t) 4201 except Exception as e: 4202 if self.parent.shouldRetry(tries, e, deadline): 4203 tries += 1 4204 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4205 continue 4206 raise plumbing.convert_error_to_porcelain(e) from e 4207 break 4208 4209 resp = models.PolicyUpdateResponse() 4210 resp.policy = plumbing.convert_policy_to_porcelain( 4211 plumbing_response.policy) 4212 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4213 plumbing_response.rate_limit) 4214 return resp 4215 4216 def get(self, id, timeout=None): 4217 ''' 4218 Get reads one Policy by ID. 4219 ''' 4220 deadline = None if timeout is None else time.time() + timeout 4221 req = PolicyGetRequest() 4222 if self.parent.snapshot_datetime is not None: 4223 req.meta.CopyFrom(GetRequestMetadata()) 4224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4225 4226 req.id = (id) 4227 tries = 0 4228 plumbing_response = None 4229 while True: 4230 t = None if deadline is None else deadline - time.time() 4231 try: 4232 plumbing_response = self.stub.Get( 4233 req, 4234 metadata=self.parent.get_metadata('Policies.Get', req), 4235 timeout=t) 4236 except Exception as e: 4237 if self.parent.shouldRetry(tries, e, deadline): 4238 tries += 1 4239 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4240 continue 4241 raise plumbing.convert_error_to_porcelain(e) from e 4242 break 4243 4244 resp = models.PolicyGetResponse() 4245 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4246 plumbing_response.meta) 4247 resp.policy = plumbing.convert_policy_to_porcelain( 4248 plumbing_response.policy) 4249 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4250 plumbing_response.rate_limit) 4251 return resp 4252 4253 def list(self, filter, *args, timeout=None): 4254 ''' 4255 List gets a list of Policy matching a given set of criteria 4256 ''' 4257 deadline = None if timeout is None else time.time() + timeout 4258 req = PolicyListRequest() 4259 req.meta.CopyFrom(ListRequestMetadata()) 4260 if self.parent.page_limit > 0: 4261 req.meta.limit = self.parent.page_limit 4262 if self.parent.snapshot_datetime is not None: 4263 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4264 4265 req.filter = plumbing.quote_filter_args(filter, *args) 4266 4267 def generator(svc, req): 4268 tries = 0 4269 while True: 4270 t = None if deadline is None else deadline - time.time() 4271 try: 4272 plumbing_response = svc.stub.List( 4273 req, 4274 metadata=svc.parent.get_metadata('Policies.List', req), 4275 timeout=t) 4276 except Exception as e: 4277 if self.parent.shouldRetry(tries, e, deadline): 4278 tries += 1 4279 time.sleep( 4280 self.parent.exponentialBackoff(tries, deadline)) 4281 continue 4282 raise plumbing.convert_error_to_porcelain(e) from e 4283 tries = 0 4284 for plumbing_item in plumbing_response.policies: 4285 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4286 if plumbing_response.meta.next_cursor == '': 4287 break 4288 req.meta.cursor = plumbing_response.meta.next_cursor 4289 4290 return generator(self, req) 4291 4292 4293class SnapshotPolicies: 4294 ''' 4295 SnapshotPolicies exposes the read only methods of the Policies 4296 service for historical queries. 4297 ''' 4298 def __init__(self, policies): 4299 self.policies = policies 4300 4301 def get(self, id, timeout=None): 4302 ''' 4303 Get reads one Policy by ID. 4304 ''' 4305 return self.policies.get(id, timeout=timeout) 4306 4307 def list(self, filter, *args, timeout=None): 4308 ''' 4309 List gets a list of Policy matching a given set of criteria 4310 ''' 4311 return self.policies.list(filter, *args, timeout=timeout) 4312 4313 4314class PoliciesHistory: 4315 ''' 4316 PoliciesHistory records all changes to the state of a Policy. 4317 See `strongdm.models.PolicyHistory`. 4318 ''' 4319 def __init__(self, channel, client): 4320 self.parent = client 4321 self.stub = PoliciesHistoryStub(channel) 4322 4323 def list(self, filter, *args, timeout=None): 4324 ''' 4325 List gets a list of PolicyHistory records matching a given set of criteria. 4326 ''' 4327 deadline = None if timeout is None else time.time() + timeout 4328 req = PoliciesHistoryListRequest() 4329 req.meta.CopyFrom(ListRequestMetadata()) 4330 if self.parent.page_limit > 0: 4331 req.meta.limit = self.parent.page_limit 4332 if self.parent.snapshot_datetime is not None: 4333 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4334 4335 req.filter = plumbing.quote_filter_args(filter, *args) 4336 4337 def generator(svc, req): 4338 tries = 0 4339 while True: 4340 t = None if deadline is None else deadline - time.time() 4341 try: 4342 plumbing_response = svc.stub.List( 4343 req, 4344 metadata=svc.parent.get_metadata( 4345 'PoliciesHistory.List', req), 4346 timeout=t) 4347 except Exception as e: 4348 if self.parent.shouldRetry(tries, e, deadline): 4349 tries += 1 4350 time.sleep( 4351 self.parent.exponentialBackoff(tries, deadline)) 4352 continue 4353 raise plumbing.convert_error_to_porcelain(e) from e 4354 tries = 0 4355 for plumbing_item in plumbing_response.history: 4356 yield plumbing.convert_policy_history_to_porcelain( 4357 plumbing_item) 4358 if plumbing_response.meta.next_cursor == '': 4359 break 4360 req.meta.cursor = plumbing_response.meta.next_cursor 4361 4362 return generator(self, req) 4363 4364 4365class ProxyClusterKeys: 4366 ''' 4367 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4368 The proxies within a cluster share the same key. One cluster can have 4369 multiple keys in order to facilitate key rotation. 4370 See `strongdm.models.ProxyClusterKey`. 4371 ''' 4372 def __init__(self, channel, client): 4373 self.parent = client 4374 self.stub = ProxyClusterKeysStub(channel) 4375 4376 def create(self, proxy_cluster_key, timeout=None): 4377 ''' 4378 Create registers a new ProxyClusterKey. 4379 ''' 4380 deadline = None if timeout is None else time.time() + timeout 4381 req = ProxyClusterKeyCreateRequest() 4382 4383 if proxy_cluster_key is not None: 4384 req.proxy_cluster_key.CopyFrom( 4385 plumbing.convert_proxy_cluster_key_to_plumbing( 4386 proxy_cluster_key)) 4387 tries = 0 4388 plumbing_response = None 4389 while True: 4390 t = None if deadline is None else deadline - time.time() 4391 try: 4392 plumbing_response = self.stub.Create( 4393 req, 4394 metadata=self.parent.get_metadata( 4395 'ProxyClusterKeys.Create', req), 4396 timeout=t) 4397 except Exception as e: 4398 if self.parent.shouldRetry(tries, e, deadline): 4399 tries += 1 4400 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4401 continue 4402 raise plumbing.convert_error_to_porcelain(e) from e 4403 break 4404 4405 resp = models.ProxyClusterKeyCreateResponse() 4406 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4407 plumbing_response.meta) 4408 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4409 plumbing_response.proxy_cluster_key) 4410 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4411 plumbing_response.rate_limit) 4412 resp.secret_key = (plumbing_response.secret_key) 4413 return resp 4414 4415 def get(self, id, timeout=None): 4416 ''' 4417 Get reads one ProxyClusterKey by ID. 4418 ''' 4419 deadline = None if timeout is None else time.time() + timeout 4420 req = ProxyClusterKeyGetRequest() 4421 if self.parent.snapshot_datetime is not None: 4422 req.meta.CopyFrom(GetRequestMetadata()) 4423 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4424 4425 req.id = (id) 4426 tries = 0 4427 plumbing_response = None 4428 while True: 4429 t = None if deadline is None else deadline - time.time() 4430 try: 4431 plumbing_response = self.stub.Get( 4432 req, 4433 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4434 req), 4435 timeout=t) 4436 except Exception as e: 4437 if self.parent.shouldRetry(tries, e, deadline): 4438 tries += 1 4439 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4440 continue 4441 raise plumbing.convert_error_to_porcelain(e) from e 4442 break 4443 4444 resp = models.ProxyClusterKeyGetResponse() 4445 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4446 plumbing_response.meta) 4447 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4448 plumbing_response.proxy_cluster_key) 4449 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4450 plumbing_response.rate_limit) 4451 return resp 4452 4453 def delete(self, id, timeout=None): 4454 ''' 4455 Delete removes a ProxyClusterKey by ID. 4456 ''' 4457 deadline = None if timeout is None else time.time() + timeout 4458 req = ProxyClusterKeyDeleteRequest() 4459 4460 req.id = (id) 4461 tries = 0 4462 plumbing_response = None 4463 while True: 4464 t = None if deadline is None else deadline - time.time() 4465 try: 4466 plumbing_response = self.stub.Delete( 4467 req, 4468 metadata=self.parent.get_metadata( 4469 'ProxyClusterKeys.Delete', req), 4470 timeout=t) 4471 except Exception as e: 4472 if self.parent.shouldRetry(tries, e, deadline): 4473 tries += 1 4474 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4475 continue 4476 raise plumbing.convert_error_to_porcelain(e) from e 4477 break 4478 4479 resp = models.ProxyClusterKeyDeleteResponse() 4480 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4481 plumbing_response.meta) 4482 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4483 plumbing_response.rate_limit) 4484 return resp 4485 4486 def list(self, filter, *args, timeout=None): 4487 ''' 4488 List gets a list of ProxyClusterKeys matching a given set of criteria. 4489 ''' 4490 deadline = None if timeout is None else time.time() + timeout 4491 req = ProxyClusterKeyListRequest() 4492 req.meta.CopyFrom(ListRequestMetadata()) 4493 if self.parent.page_limit > 0: 4494 req.meta.limit = self.parent.page_limit 4495 if self.parent.snapshot_datetime is not None: 4496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4497 4498 req.filter = plumbing.quote_filter_args(filter, *args) 4499 4500 def generator(svc, req): 4501 tries = 0 4502 while True: 4503 t = None if deadline is None else deadline - time.time() 4504 try: 4505 plumbing_response = svc.stub.List( 4506 req, 4507 metadata=svc.parent.get_metadata( 4508 'ProxyClusterKeys.List', req), 4509 timeout=t) 4510 except Exception as e: 4511 if self.parent.shouldRetry(tries, e, deadline): 4512 tries += 1 4513 time.sleep( 4514 self.parent.exponentialBackoff(tries, deadline)) 4515 continue 4516 raise plumbing.convert_error_to_porcelain(e) from e 4517 tries = 0 4518 for plumbing_item in plumbing_response.proxy_cluster_keys: 4519 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4520 plumbing_item) 4521 if plumbing_response.meta.next_cursor == '': 4522 break 4523 req.meta.cursor = plumbing_response.meta.next_cursor 4524 4525 return generator(self, req) 4526 4527 4528class SnapshotProxyClusterKeys: 4529 ''' 4530 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4531 service for historical queries. 4532 ''' 4533 def __init__(self, proxy_cluster_keys): 4534 self.proxy_cluster_keys = proxy_cluster_keys 4535 4536 def get(self, id, timeout=None): 4537 ''' 4538 Get reads one ProxyClusterKey by ID. 4539 ''' 4540 return self.proxy_cluster_keys.get(id, timeout=timeout) 4541 4542 def list(self, filter, *args, timeout=None): 4543 ''' 4544 List gets a list of ProxyClusterKeys matching a given set of criteria. 4545 ''' 4546 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 4547 4548 4549class Queries: 4550 ''' 4551 A Query is a record of a single client request to a resource, such as a SQL query. 4552 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4553 The Queries service is read-only. 4554 See `strongdm.models.Query`. 4555 ''' 4556 def __init__(self, channel, client): 4557 self.parent = client 4558 self.stub = QueriesStub(channel) 4559 4560 def list(self, filter, *args, timeout=None): 4561 ''' 4562 List gets a list of Queries matching a given set of criteria. 4563 ''' 4564 deadline = None if timeout is None else time.time() + timeout 4565 req = QueryListRequest() 4566 req.meta.CopyFrom(ListRequestMetadata()) 4567 if self.parent.page_limit > 0: 4568 req.meta.limit = self.parent.page_limit 4569 if self.parent.snapshot_datetime is not None: 4570 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4571 4572 req.filter = plumbing.quote_filter_args(filter, *args) 4573 4574 def generator(svc, req): 4575 tries = 0 4576 while True: 4577 t = None if deadline is None else deadline - time.time() 4578 try: 4579 plumbing_response = svc.stub.List( 4580 req, 4581 metadata=svc.parent.get_metadata('Queries.List', req), 4582 timeout=t) 4583 except Exception as e: 4584 if self.parent.shouldRetry(tries, e, deadline): 4585 tries += 1 4586 time.sleep( 4587 self.parent.exponentialBackoff(tries, deadline)) 4588 continue 4589 raise plumbing.convert_error_to_porcelain(e) from e 4590 tries = 0 4591 for plumbing_item in plumbing_response.queries: 4592 yield plumbing.convert_query_to_porcelain(plumbing_item) 4593 if plumbing_response.meta.next_cursor == '': 4594 break 4595 req.meta.cursor = plumbing_response.meta.next_cursor 4596 4597 return generator(self, req) 4598 4599 4600class RemoteIdentities: 4601 ''' 4602 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4603 See `strongdm.models.RemoteIdentity`. 4604 ''' 4605 def __init__(self, channel, client): 4606 self.parent = client 4607 self.stub = RemoteIdentitiesStub(channel) 4608 4609 def create(self, remote_identity, timeout=None): 4610 ''' 4611 Create registers a new RemoteIdentity. 4612 ''' 4613 deadline = None if timeout is None else time.time() + timeout 4614 req = RemoteIdentityCreateRequest() 4615 4616 if remote_identity is not None: 4617 req.remote_identity.CopyFrom( 4618 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4619 tries = 0 4620 plumbing_response = None 4621 while True: 4622 t = None if deadline is None else deadline - time.time() 4623 try: 4624 plumbing_response = self.stub.Create( 4625 req, 4626 metadata=self.parent.get_metadata( 4627 'RemoteIdentities.Create', req), 4628 timeout=t) 4629 except Exception as e: 4630 if self.parent.shouldRetry(tries, e, deadline): 4631 tries += 1 4632 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4633 continue 4634 raise plumbing.convert_error_to_porcelain(e) from e 4635 break 4636 4637 resp = models.RemoteIdentityCreateResponse() 4638 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4639 plumbing_response.meta) 4640 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4641 plumbing_response.rate_limit) 4642 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4643 plumbing_response.remote_identity) 4644 return resp 4645 4646 def get(self, id, timeout=None): 4647 ''' 4648 Get reads one RemoteIdentity by ID. 4649 ''' 4650 deadline = None if timeout is None else time.time() + timeout 4651 req = RemoteIdentityGetRequest() 4652 if self.parent.snapshot_datetime is not None: 4653 req.meta.CopyFrom(GetRequestMetadata()) 4654 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4655 4656 req.id = (id) 4657 tries = 0 4658 plumbing_response = None 4659 while True: 4660 t = None if deadline is None else deadline - time.time() 4661 try: 4662 plumbing_response = self.stub.Get( 4663 req, 4664 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4665 req), 4666 timeout=t) 4667 except Exception as e: 4668 if self.parent.shouldRetry(tries, e, deadline): 4669 tries += 1 4670 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4671 continue 4672 raise plumbing.convert_error_to_porcelain(e) from e 4673 break 4674 4675 resp = models.RemoteIdentityGetResponse() 4676 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4677 plumbing_response.meta) 4678 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4679 plumbing_response.rate_limit) 4680 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4681 plumbing_response.remote_identity) 4682 return resp 4683 4684 def update(self, remote_identity, timeout=None): 4685 ''' 4686 Update replaces all the fields of a RemoteIdentity by ID. 4687 ''' 4688 deadline = None if timeout is None else time.time() + timeout 4689 req = RemoteIdentityUpdateRequest() 4690 4691 if remote_identity is not None: 4692 req.remote_identity.CopyFrom( 4693 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4694 tries = 0 4695 plumbing_response = None 4696 while True: 4697 t = None if deadline is None else deadline - time.time() 4698 try: 4699 plumbing_response = self.stub.Update( 4700 req, 4701 metadata=self.parent.get_metadata( 4702 'RemoteIdentities.Update', req), 4703 timeout=t) 4704 except Exception as e: 4705 if self.parent.shouldRetry(tries, e, deadline): 4706 tries += 1 4707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4708 continue 4709 raise plumbing.convert_error_to_porcelain(e) from e 4710 break 4711 4712 resp = models.RemoteIdentityUpdateResponse() 4713 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4714 plumbing_response.meta) 4715 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4716 plumbing_response.rate_limit) 4717 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4718 plumbing_response.remote_identity) 4719 return resp 4720 4721 def delete(self, id, timeout=None): 4722 ''' 4723 Delete removes a RemoteIdentity by ID. 4724 ''' 4725 deadline = None if timeout is None else time.time() + timeout 4726 req = RemoteIdentityDeleteRequest() 4727 4728 req.id = (id) 4729 tries = 0 4730 plumbing_response = None 4731 while True: 4732 t = None if deadline is None else deadline - time.time() 4733 try: 4734 plumbing_response = self.stub.Delete( 4735 req, 4736 metadata=self.parent.get_metadata( 4737 'RemoteIdentities.Delete', req), 4738 timeout=t) 4739 except Exception as e: 4740 if self.parent.shouldRetry(tries, e, deadline): 4741 tries += 1 4742 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4743 continue 4744 raise plumbing.convert_error_to_porcelain(e) from e 4745 break 4746 4747 resp = models.RemoteIdentityDeleteResponse() 4748 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4749 plumbing_response.meta) 4750 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4751 plumbing_response.rate_limit) 4752 return resp 4753 4754 def list(self, filter, *args, timeout=None): 4755 ''' 4756 List gets a list of RemoteIdentities matching a given set of criteria. 4757 ''' 4758 deadline = None if timeout is None else time.time() + timeout 4759 req = RemoteIdentityListRequest() 4760 req.meta.CopyFrom(ListRequestMetadata()) 4761 if self.parent.page_limit > 0: 4762 req.meta.limit = self.parent.page_limit 4763 if self.parent.snapshot_datetime is not None: 4764 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4765 4766 req.filter = plumbing.quote_filter_args(filter, *args) 4767 4768 def generator(svc, req): 4769 tries = 0 4770 while True: 4771 t = None if deadline is None else deadline - time.time() 4772 try: 4773 plumbing_response = svc.stub.List( 4774 req, 4775 metadata=svc.parent.get_metadata( 4776 'RemoteIdentities.List', req), 4777 timeout=t) 4778 except Exception as e: 4779 if self.parent.shouldRetry(tries, e, deadline): 4780 tries += 1 4781 time.sleep( 4782 self.parent.exponentialBackoff(tries, deadline)) 4783 continue 4784 raise plumbing.convert_error_to_porcelain(e) from e 4785 tries = 0 4786 for plumbing_item in plumbing_response.remote_identities: 4787 yield plumbing.convert_remote_identity_to_porcelain( 4788 plumbing_item) 4789 if plumbing_response.meta.next_cursor == '': 4790 break 4791 req.meta.cursor = plumbing_response.meta.next_cursor 4792 4793 return generator(self, req) 4794 4795 4796class SnapshotRemoteIdentities: 4797 ''' 4798 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 4799 service for historical queries. 4800 ''' 4801 def __init__(self, remote_identities): 4802 self.remote_identities = remote_identities 4803 4804 def get(self, id, timeout=None): 4805 ''' 4806 Get reads one RemoteIdentity by ID. 4807 ''' 4808 return self.remote_identities.get(id, timeout=timeout) 4809 4810 def list(self, filter, *args, timeout=None): 4811 ''' 4812 List gets a list of RemoteIdentities matching a given set of criteria. 4813 ''' 4814 return self.remote_identities.list(filter, *args, timeout=timeout) 4815 4816 4817class RemoteIdentitiesHistory: 4818 ''' 4819 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 4820 See `strongdm.models.RemoteIdentityHistory`. 4821 ''' 4822 def __init__(self, channel, client): 4823 self.parent = client 4824 self.stub = RemoteIdentitiesHistoryStub(channel) 4825 4826 def list(self, filter, *args, timeout=None): 4827 ''' 4828 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4829 ''' 4830 deadline = None if timeout is None else time.time() + timeout 4831 req = RemoteIdentityHistoryListRequest() 4832 req.meta.CopyFrom(ListRequestMetadata()) 4833 if self.parent.page_limit > 0: 4834 req.meta.limit = self.parent.page_limit 4835 if self.parent.snapshot_datetime is not None: 4836 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4837 4838 req.filter = plumbing.quote_filter_args(filter, *args) 4839 4840 def generator(svc, req): 4841 tries = 0 4842 while True: 4843 t = None if deadline is None else deadline - time.time() 4844 try: 4845 plumbing_response = svc.stub.List( 4846 req, 4847 metadata=svc.parent.get_metadata( 4848 'RemoteIdentitiesHistory.List', req), 4849 timeout=t) 4850 except Exception as e: 4851 if self.parent.shouldRetry(tries, e, deadline): 4852 tries += 1 4853 time.sleep( 4854 self.parent.exponentialBackoff(tries, deadline)) 4855 continue 4856 raise plumbing.convert_error_to_porcelain(e) from e 4857 tries = 0 4858 for plumbing_item in plumbing_response.history: 4859 yield plumbing.convert_remote_identity_history_to_porcelain( 4860 plumbing_item) 4861 if plumbing_response.meta.next_cursor == '': 4862 break 4863 req.meta.cursor = plumbing_response.meta.next_cursor 4864 4865 return generator(self, req) 4866 4867 4868class RemoteIdentityGroups: 4869 ''' 4870 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 4871 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 4872 See `strongdm.models.RemoteIdentityGroup`. 4873 ''' 4874 def __init__(self, channel, client): 4875 self.parent = client 4876 self.stub = RemoteIdentityGroupsStub(channel) 4877 4878 def get(self, id, timeout=None): 4879 ''' 4880 Get reads one RemoteIdentityGroup by ID. 4881 ''' 4882 deadline = None if timeout is None else time.time() + timeout 4883 req = RemoteIdentityGroupGetRequest() 4884 if self.parent.snapshot_datetime is not None: 4885 req.meta.CopyFrom(GetRequestMetadata()) 4886 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4887 4888 req.id = (id) 4889 tries = 0 4890 plumbing_response = None 4891 while True: 4892 t = None if deadline is None else deadline - time.time() 4893 try: 4894 plumbing_response = self.stub.Get( 4895 req, 4896 metadata=self.parent.get_metadata( 4897 'RemoteIdentityGroups.Get', req), 4898 timeout=t) 4899 except Exception as e: 4900 if self.parent.shouldRetry(tries, e, deadline): 4901 tries += 1 4902 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4903 continue 4904 raise plumbing.convert_error_to_porcelain(e) from e 4905 break 4906 4907 resp = models.RemoteIdentityGroupGetResponse() 4908 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4909 plumbing_response.meta) 4910 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4911 plumbing_response.rate_limit) 4912 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4913 plumbing_response.remote_identity_group) 4914 return resp 4915 4916 def list(self, filter, *args, timeout=None): 4917 ''' 4918 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4919 ''' 4920 deadline = None if timeout is None else time.time() + timeout 4921 req = RemoteIdentityGroupListRequest() 4922 req.meta.CopyFrom(ListRequestMetadata()) 4923 if self.parent.page_limit > 0: 4924 req.meta.limit = self.parent.page_limit 4925 if self.parent.snapshot_datetime is not None: 4926 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4927 4928 req.filter = plumbing.quote_filter_args(filter, *args) 4929 4930 def generator(svc, req): 4931 tries = 0 4932 while True: 4933 t = None if deadline is None else deadline - time.time() 4934 try: 4935 plumbing_response = svc.stub.List( 4936 req, 4937 metadata=svc.parent.get_metadata( 4938 'RemoteIdentityGroups.List', req), 4939 timeout=t) 4940 except Exception as e: 4941 if self.parent.shouldRetry(tries, e, deadline): 4942 tries += 1 4943 time.sleep( 4944 self.parent.exponentialBackoff(tries, deadline)) 4945 continue 4946 raise plumbing.convert_error_to_porcelain(e) from e 4947 tries = 0 4948 for plumbing_item in plumbing_response.remote_identity_groups: 4949 yield plumbing.convert_remote_identity_group_to_porcelain( 4950 plumbing_item) 4951 if plumbing_response.meta.next_cursor == '': 4952 break 4953 req.meta.cursor = plumbing_response.meta.next_cursor 4954 4955 return generator(self, req) 4956 4957 4958class SnapshotRemoteIdentityGroups: 4959 ''' 4960 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 4961 service for historical queries. 4962 ''' 4963 def __init__(self, remote_identity_groups): 4964 self.remote_identity_groups = remote_identity_groups 4965 4966 def get(self, id, timeout=None): 4967 ''' 4968 Get reads one RemoteIdentityGroup by ID. 4969 ''' 4970 return self.remote_identity_groups.get(id, timeout=timeout) 4971 4972 def list(self, filter, *args, timeout=None): 4973 ''' 4974 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4975 ''' 4976 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 4977 4978 4979class RemoteIdentityGroupsHistory: 4980 ''' 4981 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 4982 See `strongdm.models.RemoteIdentityGroupHistory`. 4983 ''' 4984 def __init__(self, channel, client): 4985 self.parent = client 4986 self.stub = RemoteIdentityGroupsHistoryStub(channel) 4987 4988 def list(self, filter, *args, timeout=None): 4989 ''' 4990 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4991 ''' 4992 deadline = None if timeout is None else time.time() + timeout 4993 req = RemoteIdentityGroupHistoryListRequest() 4994 req.meta.CopyFrom(ListRequestMetadata()) 4995 if self.parent.page_limit > 0: 4996 req.meta.limit = self.parent.page_limit 4997 if self.parent.snapshot_datetime is not None: 4998 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4999 5000 req.filter = plumbing.quote_filter_args(filter, *args) 5001 5002 def generator(svc, req): 5003 tries = 0 5004 while True: 5005 t = None if deadline is None else deadline - time.time() 5006 try: 5007 plumbing_response = svc.stub.List( 5008 req, 5009 metadata=svc.parent.get_metadata( 5010 'RemoteIdentityGroupsHistory.List', req), 5011 timeout=t) 5012 except Exception as e: 5013 if self.parent.shouldRetry(tries, e, deadline): 5014 tries += 1 5015 time.sleep( 5016 self.parent.exponentialBackoff(tries, deadline)) 5017 continue 5018 raise plumbing.convert_error_to_porcelain(e) from e 5019 tries = 0 5020 for plumbing_item in plumbing_response.history: 5021 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5022 plumbing_item) 5023 if plumbing_response.meta.next_cursor == '': 5024 break 5025 req.meta.cursor = plumbing_response.meta.next_cursor 5026 5027 return generator(self, req) 5028 5029 5030class Replays: 5031 ''' 5032 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5033 (otherwise referred to as a query). The Replays service is read-only. 5034 See `strongdm.models.ReplayChunk`. 5035 ''' 5036 def __init__(self, channel, client): 5037 self.parent = client 5038 self.stub = ReplaysStub(channel) 5039 5040 def list(self, filter, *args, timeout=None): 5041 ''' 5042 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5043 ''' 5044 deadline = None if timeout is None else time.time() + timeout 5045 req = ReplayListRequest() 5046 req.meta.CopyFrom(ListRequestMetadata()) 5047 if self.parent.page_limit > 0: 5048 req.meta.limit = self.parent.page_limit 5049 if self.parent.snapshot_datetime is not None: 5050 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5051 5052 req.filter = plumbing.quote_filter_args(filter, *args) 5053 5054 def generator(svc, req): 5055 tries = 0 5056 while True: 5057 t = None if deadline is None else deadline - time.time() 5058 try: 5059 plumbing_response = svc.stub.List( 5060 req, 5061 metadata=svc.parent.get_metadata('Replays.List', req), 5062 timeout=t) 5063 except Exception as e: 5064 if self.parent.shouldRetry(tries, e, deadline): 5065 tries += 1 5066 time.sleep( 5067 self.parent.exponentialBackoff(tries, deadline)) 5068 continue 5069 raise plumbing.convert_error_to_porcelain(e) from e 5070 tries = 0 5071 for plumbing_item in plumbing_response.chunks: 5072 yield plumbing.convert_replay_chunk_to_porcelain( 5073 plumbing_item) 5074 if plumbing_response.meta.next_cursor == '': 5075 break 5076 req.meta.cursor = plumbing_response.meta.next_cursor 5077 5078 return generator(self, req) 5079 5080 5081class Resources: 5082 ''' 5083 Resources are databases, servers, clusters, websites, or clouds that strongDM 5084 delegates access to. 5085 See: 5086 `strongdm.models.Aerospike` 5087 `strongdm.models.AKS` 5088 `strongdm.models.AKSBasicAuth` 5089 `strongdm.models.AKSServiceAccount` 5090 `strongdm.models.AKSServiceAccountUserImpersonation` 5091 `strongdm.models.AKSUserImpersonation` 5092 `strongdm.models.AmazonEKS` 5093 `strongdm.models.AmazonEKSInstanceProfile` 5094 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5095 `strongdm.models.AmazonEKSUserImpersonation` 5096 `strongdm.models.AmazonES` 5097 `strongdm.models.AmazonESIAM` 5098 `strongdm.models.AmazonMQAMQP091` 5099 `strongdm.models.Athena` 5100 `strongdm.models.AthenaIAM` 5101 `strongdm.models.AuroraMysql` 5102 `strongdm.models.AuroraMysqlIAM` 5103 `strongdm.models.AuroraPostgres` 5104 `strongdm.models.AuroraPostgresIAM` 5105 `strongdm.models.AWS` 5106 `strongdm.models.AWSConsole` 5107 `strongdm.models.AWSConsoleStaticKeyPair` 5108 `strongdm.models.AWSInstanceProfile` 5109 `strongdm.models.Azure` 5110 `strongdm.models.AzureCertificate` 5111 `strongdm.models.AzureConsole` 5112 `strongdm.models.AzureMysql` 5113 `strongdm.models.AzurePostgres` 5114 `strongdm.models.AzurePostgresManagedIdentity` 5115 `strongdm.models.BigQuery` 5116 `strongdm.models.Cassandra` 5117 `strongdm.models.Citus` 5118 `strongdm.models.ClickHouseHTTP` 5119 `strongdm.models.ClickHouseMySQL` 5120 `strongdm.models.ClickHouseTCP` 5121 `strongdm.models.Clustrix` 5122 `strongdm.models.Cockroach` 5123 `strongdm.models.CouchbaseDatabase` 5124 `strongdm.models.CouchbaseWebUI` 5125 `strongdm.models.DB2I` 5126 `strongdm.models.DB2LUW` 5127 `strongdm.models.DocumentDBHost` 5128 `strongdm.models.DocumentDBHostIAM` 5129 `strongdm.models.DocumentDBReplicaSet` 5130 `strongdm.models.DocumentDBReplicaSetIAM` 5131 `strongdm.models.Druid` 5132 `strongdm.models.DynamoDB` 5133 `strongdm.models.DynamoDBIAM` 5134 `strongdm.models.Elastic` 5135 `strongdm.models.ElasticacheRedis` 5136 `strongdm.models.GCP` 5137 `strongdm.models.GCPConsole` 5138 `strongdm.models.GCPWIF` 5139 `strongdm.models.GoogleGKE` 5140 `strongdm.models.GoogleGKEUserImpersonation` 5141 `strongdm.models.Greenplum` 5142 `strongdm.models.HTTPAuth` 5143 `strongdm.models.HTTPBasicAuth` 5144 `strongdm.models.HTTPNoAuth` 5145 `strongdm.models.Kubernetes` 5146 `strongdm.models.KubernetesBasicAuth` 5147 `strongdm.models.KubernetesPodIdentity` 5148 `strongdm.models.KubernetesServiceAccount` 5149 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5150 `strongdm.models.KubernetesUserImpersonation` 5151 `strongdm.models.Maria` 5152 `strongdm.models.Memcached` 5153 `strongdm.models.Memsql` 5154 `strongdm.models.MongoHost` 5155 `strongdm.models.MongoLegacyHost` 5156 `strongdm.models.MongoLegacyReplicaset` 5157 `strongdm.models.MongoReplicaSet` 5158 `strongdm.models.MongoShardedCluster` 5159 `strongdm.models.MTLSMysql` 5160 `strongdm.models.MTLSPostgres` 5161 `strongdm.models.Mysql` 5162 `strongdm.models.Neptune` 5163 `strongdm.models.NeptuneIAM` 5164 `strongdm.models.Oracle` 5165 `strongdm.models.OracleNNE` 5166 `strongdm.models.Postgres` 5167 `strongdm.models.Presto` 5168 `strongdm.models.RabbitMQAMQP091` 5169 `strongdm.models.RawTCP` 5170 `strongdm.models.RDP` 5171 `strongdm.models.RDPCert` 5172 `strongdm.models.RDSPostgresIAM` 5173 `strongdm.models.Redis` 5174 `strongdm.models.RedisCluster` 5175 `strongdm.models.Redshift` 5176 `strongdm.models.RedshiftIAM` 5177 `strongdm.models.RedshiftServerlessIAM` 5178 `strongdm.models.SingleStore` 5179 `strongdm.models.Snowflake` 5180 `strongdm.models.Snowsight` 5181 `strongdm.models.SQLServer` 5182 `strongdm.models.SQLServerAzureAD` 5183 `strongdm.models.SQLServerKerberosAD` 5184 `strongdm.models.SSH` 5185 `strongdm.models.SSHCert` 5186 `strongdm.models.SSHCustomerKey` 5187 `strongdm.models.SSHPassword` 5188 `strongdm.models.Sybase` 5189 `strongdm.models.SybaseIQ` 5190 `strongdm.models.Teradata` 5191 `strongdm.models.Trino` 5192 `strongdm.models.Vertica` 5193 ''' 5194 def __init__(self, channel, client): 5195 self.parent = client 5196 self.stub = ResourcesStub(channel) 5197 5198 def enumerate_tags(self, filter, *args, timeout=None): 5199 ''' 5200 EnumerateTags gets a list of the filter matching tags. 5201 ''' 5202 deadline = None if timeout is None else time.time() + timeout 5203 req = EnumerateTagsRequest() 5204 req.meta.CopyFrom(ListRequestMetadata()) 5205 if self.parent.page_limit > 0: 5206 req.meta.limit = self.parent.page_limit 5207 if self.parent.snapshot_datetime is not None: 5208 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5209 5210 req.filter = plumbing.quote_filter_args(filter, *args) 5211 5212 def generator(svc, req): 5213 tries = 0 5214 while True: 5215 t = None if deadline is None else deadline - time.time() 5216 try: 5217 plumbing_response = svc.stub.EnumerateTags( 5218 req, 5219 metadata=svc.parent.get_metadata( 5220 'Resources.EnumerateTags', req), 5221 timeout=t) 5222 except Exception as e: 5223 if self.parent.shouldRetry(tries, e, deadline): 5224 tries += 1 5225 time.sleep( 5226 self.parent.exponentialBackoff(tries, deadline)) 5227 continue 5228 raise plumbing.convert_error_to_porcelain(e) from e 5229 tries = 0 5230 for plumbing_item in plumbing_response.matches: 5231 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5232 if plumbing_response.meta.next_cursor == '': 5233 break 5234 req.meta.cursor = plumbing_response.meta.next_cursor 5235 5236 return generator(self, req) 5237 5238 def create(self, resource, timeout=None): 5239 ''' 5240 Create registers a new Resource. 5241 ''' 5242 deadline = None if timeout is None else time.time() + timeout 5243 req = ResourceCreateRequest() 5244 5245 if resource is not None: 5246 req.resource.CopyFrom( 5247 plumbing.convert_resource_to_plumbing(resource)) 5248 tries = 0 5249 plumbing_response = None 5250 while True: 5251 t = None if deadline is None else deadline - time.time() 5252 try: 5253 plumbing_response = self.stub.Create( 5254 req, 5255 metadata=self.parent.get_metadata('Resources.Create', req), 5256 timeout=t) 5257 except Exception as e: 5258 if self.parent.shouldRetry(tries, e, deadline): 5259 tries += 1 5260 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5261 continue 5262 raise plumbing.convert_error_to_porcelain(e) from e 5263 break 5264 5265 resp = models.ResourceCreateResponse() 5266 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5267 plumbing_response.meta) 5268 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5269 plumbing_response.rate_limit) 5270 resp.resource = plumbing.convert_resource_to_porcelain( 5271 plumbing_response.resource) 5272 return resp 5273 5274 def get(self, id, timeout=None): 5275 ''' 5276 Get reads one Resource by ID. 5277 ''' 5278 deadline = None if timeout is None else time.time() + timeout 5279 req = ResourceGetRequest() 5280 if self.parent.snapshot_datetime is not None: 5281 req.meta.CopyFrom(GetRequestMetadata()) 5282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5283 5284 req.id = (id) 5285 tries = 0 5286 plumbing_response = None 5287 while True: 5288 t = None if deadline is None else deadline - time.time() 5289 try: 5290 plumbing_response = self.stub.Get( 5291 req, 5292 metadata=self.parent.get_metadata('Resources.Get', req), 5293 timeout=t) 5294 except Exception as e: 5295 if self.parent.shouldRetry(tries, e, deadline): 5296 tries += 1 5297 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5298 continue 5299 raise plumbing.convert_error_to_porcelain(e) from e 5300 break 5301 5302 resp = models.ResourceGetResponse() 5303 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5304 plumbing_response.meta) 5305 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5306 plumbing_response.rate_limit) 5307 resp.resource = plumbing.convert_resource_to_porcelain( 5308 plumbing_response.resource) 5309 return resp 5310 5311 def update(self, resource, timeout=None): 5312 ''' 5313 Update replaces all the fields of a Resource by ID. 5314 ''' 5315 deadline = None if timeout is None else time.time() + timeout 5316 req = ResourceUpdateRequest() 5317 5318 if resource is not None: 5319 req.resource.CopyFrom( 5320 plumbing.convert_resource_to_plumbing(resource)) 5321 tries = 0 5322 plumbing_response = None 5323 while True: 5324 t = None if deadline is None else deadline - time.time() 5325 try: 5326 plumbing_response = self.stub.Update( 5327 req, 5328 metadata=self.parent.get_metadata('Resources.Update', req), 5329 timeout=t) 5330 except Exception as e: 5331 if self.parent.shouldRetry(tries, e, deadline): 5332 tries += 1 5333 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5334 continue 5335 raise plumbing.convert_error_to_porcelain(e) from e 5336 break 5337 5338 resp = models.ResourceUpdateResponse() 5339 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5340 plumbing_response.meta) 5341 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5342 plumbing_response.rate_limit) 5343 resp.resource = plumbing.convert_resource_to_porcelain( 5344 plumbing_response.resource) 5345 return resp 5346 5347 def delete(self, id, timeout=None): 5348 ''' 5349 Delete removes a Resource by ID. 5350 ''' 5351 deadline = None if timeout is None else time.time() + timeout 5352 req = ResourceDeleteRequest() 5353 5354 req.id = (id) 5355 tries = 0 5356 plumbing_response = None 5357 while True: 5358 t = None if deadline is None else deadline - time.time() 5359 try: 5360 plumbing_response = self.stub.Delete( 5361 req, 5362 metadata=self.parent.get_metadata('Resources.Delete', req), 5363 timeout=t) 5364 except Exception as e: 5365 if self.parent.shouldRetry(tries, e, deadline): 5366 tries += 1 5367 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5368 continue 5369 raise plumbing.convert_error_to_porcelain(e) from e 5370 break 5371 5372 resp = models.ResourceDeleteResponse() 5373 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5374 plumbing_response.meta) 5375 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5376 plumbing_response.rate_limit) 5377 return resp 5378 5379 def list(self, filter, *args, timeout=None): 5380 ''' 5381 List gets a list of Resources matching a given set of criteria. 5382 ''' 5383 deadline = None if timeout is None else time.time() + timeout 5384 req = ResourceListRequest() 5385 req.meta.CopyFrom(ListRequestMetadata()) 5386 if self.parent.page_limit > 0: 5387 req.meta.limit = self.parent.page_limit 5388 if self.parent.snapshot_datetime is not None: 5389 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5390 5391 req.filter = plumbing.quote_filter_args(filter, *args) 5392 5393 def generator(svc, req): 5394 tries = 0 5395 while True: 5396 t = None if deadline is None else deadline - time.time() 5397 try: 5398 plumbing_response = svc.stub.List( 5399 req, 5400 metadata=svc.parent.get_metadata( 5401 'Resources.List', req), 5402 timeout=t) 5403 except Exception as e: 5404 if self.parent.shouldRetry(tries, e, deadline): 5405 tries += 1 5406 time.sleep( 5407 self.parent.exponentialBackoff(tries, deadline)) 5408 continue 5409 raise plumbing.convert_error_to_porcelain(e) from e 5410 tries = 0 5411 for plumbing_item in plumbing_response.resources: 5412 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5413 if plumbing_response.meta.next_cursor == '': 5414 break 5415 req.meta.cursor = plumbing_response.meta.next_cursor 5416 5417 return generator(self, req) 5418 5419 def healthcheck(self, id, timeout=None): 5420 ''' 5421 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5422 large network of Nodes. The call will return immediately, and the updated health of the 5423 Resource can be retrieved via Get or List. 5424 ''' 5425 deadline = None if timeout is None else time.time() + timeout 5426 req = ResourceHealthcheckRequest() 5427 5428 req.id = (id) 5429 tries = 0 5430 plumbing_response = None 5431 while True: 5432 t = None if deadline is None else deadline - time.time() 5433 try: 5434 plumbing_response = self.stub.Healthcheck( 5435 req, 5436 metadata=self.parent.get_metadata('Resources.Healthcheck', 5437 req), 5438 timeout=t) 5439 except Exception as e: 5440 if self.parent.shouldRetry(tries, e, deadline): 5441 tries += 1 5442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5443 continue 5444 raise plumbing.convert_error_to_porcelain(e) from e 5445 break 5446 5447 resp = models.ResourceHealthcheckResponse() 5448 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5449 plumbing_response.meta) 5450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5451 plumbing_response.rate_limit) 5452 return resp 5453 5454 5455class SnapshotResources: 5456 ''' 5457 SnapshotResources exposes the read only methods of the Resources 5458 service for historical queries. 5459 ''' 5460 def __init__(self, resources): 5461 self.resources = resources 5462 5463 def get(self, id, timeout=None): 5464 ''' 5465 Get reads one Resource by ID. 5466 ''' 5467 return self.resources.get(id, timeout=timeout) 5468 5469 def list(self, filter, *args, timeout=None): 5470 ''' 5471 List gets a list of Resources matching a given set of criteria. 5472 ''' 5473 return self.resources.list(filter, *args, timeout=timeout) 5474 5475 5476class ResourcesHistory: 5477 ''' 5478 ResourcesHistory records all changes to the state of a Resource. 5479 See `strongdm.models.ResourceHistory`. 5480 ''' 5481 def __init__(self, channel, client): 5482 self.parent = client 5483 self.stub = ResourcesHistoryStub(channel) 5484 5485 def list(self, filter, *args, timeout=None): 5486 ''' 5487 List gets a list of ResourceHistory records matching a given set of criteria. 5488 ''' 5489 deadline = None if timeout is None else time.time() + timeout 5490 req = ResourceHistoryListRequest() 5491 req.meta.CopyFrom(ListRequestMetadata()) 5492 if self.parent.page_limit > 0: 5493 req.meta.limit = self.parent.page_limit 5494 if self.parent.snapshot_datetime is not None: 5495 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5496 5497 req.filter = plumbing.quote_filter_args(filter, *args) 5498 5499 def generator(svc, req): 5500 tries = 0 5501 while True: 5502 t = None if deadline is None else deadline - time.time() 5503 try: 5504 plumbing_response = svc.stub.List( 5505 req, 5506 metadata=svc.parent.get_metadata( 5507 'ResourcesHistory.List', req), 5508 timeout=t) 5509 except Exception as e: 5510 if self.parent.shouldRetry(tries, e, deadline): 5511 tries += 1 5512 time.sleep( 5513 self.parent.exponentialBackoff(tries, deadline)) 5514 continue 5515 raise plumbing.convert_error_to_porcelain(e) from e 5516 tries = 0 5517 for plumbing_item in plumbing_response.history: 5518 yield plumbing.convert_resource_history_to_porcelain( 5519 plumbing_item) 5520 if plumbing_response.meta.next_cursor == '': 5521 break 5522 req.meta.cursor = plumbing_response.meta.next_cursor 5523 5524 return generator(self, req) 5525 5526 5527class RoleResources: 5528 ''' 5529 RoleResources enumerates the resources to which roles have access. 5530 The RoleResources service is read-only. 5531 See `strongdm.models.RoleResource`. 5532 ''' 5533 def __init__(self, channel, client): 5534 self.parent = client 5535 self.stub = RoleResourcesStub(channel) 5536 5537 def list(self, filter, *args, timeout=None): 5538 ''' 5539 List gets a list of RoleResource records matching a given set of criteria. 5540 ''' 5541 deadline = None if timeout is None else time.time() + timeout 5542 req = RoleResourceListRequest() 5543 req.meta.CopyFrom(ListRequestMetadata()) 5544 if self.parent.page_limit > 0: 5545 req.meta.limit = self.parent.page_limit 5546 if self.parent.snapshot_datetime is not None: 5547 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5548 5549 req.filter = plumbing.quote_filter_args(filter, *args) 5550 5551 def generator(svc, req): 5552 tries = 0 5553 while True: 5554 t = None if deadline is None else deadline - time.time() 5555 try: 5556 plumbing_response = svc.stub.List( 5557 req, 5558 metadata=svc.parent.get_metadata( 5559 'RoleResources.List', req), 5560 timeout=t) 5561 except Exception as e: 5562 if self.parent.shouldRetry(tries, e, deadline): 5563 tries += 1 5564 time.sleep( 5565 self.parent.exponentialBackoff(tries, deadline)) 5566 continue 5567 raise plumbing.convert_error_to_porcelain(e) from e 5568 tries = 0 5569 for plumbing_item in plumbing_response.role_resources: 5570 yield plumbing.convert_role_resource_to_porcelain( 5571 plumbing_item) 5572 if plumbing_response.meta.next_cursor == '': 5573 break 5574 req.meta.cursor = plumbing_response.meta.next_cursor 5575 5576 return generator(self, req) 5577 5578 5579class SnapshotRoleResources: 5580 ''' 5581 SnapshotRoleResources exposes the read only methods of the RoleResources 5582 service for historical queries. 5583 ''' 5584 def __init__(self, role_resources): 5585 self.role_resources = role_resources 5586 5587 def list(self, filter, *args, timeout=None): 5588 ''' 5589 List gets a list of RoleResource records matching a given set of criteria. 5590 ''' 5591 return self.role_resources.list(filter, *args, timeout=timeout) 5592 5593 5594class RoleResourcesHistory: 5595 ''' 5596 RoleResourcesHistory records all changes to the state of a RoleResource. 5597 See `strongdm.models.RoleResourceHistory`. 5598 ''' 5599 def __init__(self, channel, client): 5600 self.parent = client 5601 self.stub = RoleResourcesHistoryStub(channel) 5602 5603 def list(self, filter, *args, timeout=None): 5604 ''' 5605 List gets a list of RoleResourceHistory records matching a given set of criteria. 5606 ''' 5607 deadline = None if timeout is None else time.time() + timeout 5608 req = RoleResourceHistoryListRequest() 5609 req.meta.CopyFrom(ListRequestMetadata()) 5610 if self.parent.page_limit > 0: 5611 req.meta.limit = self.parent.page_limit 5612 if self.parent.snapshot_datetime is not None: 5613 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5614 5615 req.filter = plumbing.quote_filter_args(filter, *args) 5616 5617 def generator(svc, req): 5618 tries = 0 5619 while True: 5620 t = None if deadline is None else deadline - time.time() 5621 try: 5622 plumbing_response = svc.stub.List( 5623 req, 5624 metadata=svc.parent.get_metadata( 5625 'RoleResourcesHistory.List', req), 5626 timeout=t) 5627 except Exception as e: 5628 if self.parent.shouldRetry(tries, e, deadline): 5629 tries += 1 5630 time.sleep( 5631 self.parent.exponentialBackoff(tries, deadline)) 5632 continue 5633 raise plumbing.convert_error_to_porcelain(e) from e 5634 tries = 0 5635 for plumbing_item in plumbing_response.history: 5636 yield plumbing.convert_role_resource_history_to_porcelain( 5637 plumbing_item) 5638 if plumbing_response.meta.next_cursor == '': 5639 break 5640 req.meta.cursor = plumbing_response.meta.next_cursor 5641 5642 return generator(self, req) 5643 5644 5645class Roles: 5646 ''' 5647 A Role has a list of access rules which determine which Resources the members 5648 of the Role have access to. An Account can be a member of multiple Roles via 5649 AccountAttachments. 5650 See `strongdm.models.Role`. 5651 ''' 5652 def __init__(self, channel, client): 5653 self.parent = client 5654 self.stub = RolesStub(channel) 5655 5656 def create(self, role, timeout=None): 5657 ''' 5658 Create registers a new Role. 5659 ''' 5660 deadline = None if timeout is None else time.time() + timeout 5661 req = RoleCreateRequest() 5662 5663 if role is not None: 5664 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5665 tries = 0 5666 plumbing_response = None 5667 while True: 5668 t = None if deadline is None else deadline - time.time() 5669 try: 5670 plumbing_response = self.stub.Create( 5671 req, 5672 metadata=self.parent.get_metadata('Roles.Create', req), 5673 timeout=t) 5674 except Exception as e: 5675 if self.parent.shouldRetry(tries, e, deadline): 5676 tries += 1 5677 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5678 continue 5679 raise plumbing.convert_error_to_porcelain(e) from e 5680 break 5681 5682 resp = models.RoleCreateResponse() 5683 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5684 plumbing_response.meta) 5685 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5686 plumbing_response.rate_limit) 5687 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5688 return resp 5689 5690 def get(self, id, timeout=None): 5691 ''' 5692 Get reads one Role by ID. 5693 ''' 5694 deadline = None if timeout is None else time.time() + timeout 5695 req = RoleGetRequest() 5696 if self.parent.snapshot_datetime is not None: 5697 req.meta.CopyFrom(GetRequestMetadata()) 5698 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5699 5700 req.id = (id) 5701 tries = 0 5702 plumbing_response = None 5703 while True: 5704 t = None if deadline is None else deadline - time.time() 5705 try: 5706 plumbing_response = self.stub.Get( 5707 req, 5708 metadata=self.parent.get_metadata('Roles.Get', req), 5709 timeout=t) 5710 except Exception as e: 5711 if self.parent.shouldRetry(tries, e, deadline): 5712 tries += 1 5713 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5714 continue 5715 raise plumbing.convert_error_to_porcelain(e) from e 5716 break 5717 5718 resp = models.RoleGetResponse() 5719 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5720 plumbing_response.meta) 5721 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5722 plumbing_response.rate_limit) 5723 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5724 return resp 5725 5726 def update(self, role, timeout=None): 5727 ''' 5728 Update replaces all the fields of a Role by ID. 5729 ''' 5730 deadline = None if timeout is None else time.time() + timeout 5731 req = RoleUpdateRequest() 5732 5733 if role is not None: 5734 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5735 tries = 0 5736 plumbing_response = None 5737 while True: 5738 t = None if deadline is None else deadline - time.time() 5739 try: 5740 plumbing_response = self.stub.Update( 5741 req, 5742 metadata=self.parent.get_metadata('Roles.Update', req), 5743 timeout=t) 5744 except Exception as e: 5745 if self.parent.shouldRetry(tries, e, deadline): 5746 tries += 1 5747 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5748 continue 5749 raise plumbing.convert_error_to_porcelain(e) from e 5750 break 5751 5752 resp = models.RoleUpdateResponse() 5753 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5754 plumbing_response.meta) 5755 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5756 plumbing_response.rate_limit) 5757 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5758 return resp 5759 5760 def delete(self, id, timeout=None): 5761 ''' 5762 Delete removes a Role by ID. 5763 ''' 5764 deadline = None if timeout is None else time.time() + timeout 5765 req = RoleDeleteRequest() 5766 5767 req.id = (id) 5768 tries = 0 5769 plumbing_response = None 5770 while True: 5771 t = None if deadline is None else deadline - time.time() 5772 try: 5773 plumbing_response = self.stub.Delete( 5774 req, 5775 metadata=self.parent.get_metadata('Roles.Delete', req), 5776 timeout=t) 5777 except Exception as e: 5778 if self.parent.shouldRetry(tries, e, deadline): 5779 tries += 1 5780 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5781 continue 5782 raise plumbing.convert_error_to_porcelain(e) from e 5783 break 5784 5785 resp = models.RoleDeleteResponse() 5786 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5787 plumbing_response.meta) 5788 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5789 plumbing_response.rate_limit) 5790 return resp 5791 5792 def list(self, filter, *args, timeout=None): 5793 ''' 5794 List gets a list of Roles matching a given set of criteria. 5795 ''' 5796 deadline = None if timeout is None else time.time() + timeout 5797 req = RoleListRequest() 5798 req.meta.CopyFrom(ListRequestMetadata()) 5799 if self.parent.page_limit > 0: 5800 req.meta.limit = self.parent.page_limit 5801 if self.parent.snapshot_datetime is not None: 5802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5803 5804 req.filter = plumbing.quote_filter_args(filter, *args) 5805 5806 def generator(svc, req): 5807 tries = 0 5808 while True: 5809 t = None if deadline is None else deadline - time.time() 5810 try: 5811 plumbing_response = svc.stub.List( 5812 req, 5813 metadata=svc.parent.get_metadata('Roles.List', req), 5814 timeout=t) 5815 except Exception as e: 5816 if self.parent.shouldRetry(tries, e, deadline): 5817 tries += 1 5818 time.sleep( 5819 self.parent.exponentialBackoff(tries, deadline)) 5820 continue 5821 raise plumbing.convert_error_to_porcelain(e) from e 5822 tries = 0 5823 for plumbing_item in plumbing_response.roles: 5824 yield plumbing.convert_role_to_porcelain(plumbing_item) 5825 if plumbing_response.meta.next_cursor == '': 5826 break 5827 req.meta.cursor = plumbing_response.meta.next_cursor 5828 5829 return generator(self, req) 5830 5831 5832class SnapshotRoles: 5833 ''' 5834 SnapshotRoles exposes the read only methods of the Roles 5835 service for historical queries. 5836 ''' 5837 def __init__(self, roles): 5838 self.roles = roles 5839 5840 def get(self, id, timeout=None): 5841 ''' 5842 Get reads one Role by ID. 5843 ''' 5844 return self.roles.get(id, timeout=timeout) 5845 5846 def list(self, filter, *args, timeout=None): 5847 ''' 5848 List gets a list of Roles matching a given set of criteria. 5849 ''' 5850 return self.roles.list(filter, *args, timeout=timeout) 5851 5852 5853class RolesHistory: 5854 ''' 5855 RolesHistory records all changes to the state of a Role. 5856 See `strongdm.models.RoleHistory`. 5857 ''' 5858 def __init__(self, channel, client): 5859 self.parent = client 5860 self.stub = RolesHistoryStub(channel) 5861 5862 def list(self, filter, *args, timeout=None): 5863 ''' 5864 List gets a list of RoleHistory records matching a given set of criteria. 5865 ''' 5866 deadline = None if timeout is None else time.time() + timeout 5867 req = RoleHistoryListRequest() 5868 req.meta.CopyFrom(ListRequestMetadata()) 5869 if self.parent.page_limit > 0: 5870 req.meta.limit = self.parent.page_limit 5871 if self.parent.snapshot_datetime is not None: 5872 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5873 5874 req.filter = plumbing.quote_filter_args(filter, *args) 5875 5876 def generator(svc, req): 5877 tries = 0 5878 while True: 5879 t = None if deadline is None else deadline - time.time() 5880 try: 5881 plumbing_response = svc.stub.List( 5882 req, 5883 metadata=svc.parent.get_metadata( 5884 'RolesHistory.List', req), 5885 timeout=t) 5886 except Exception as e: 5887 if self.parent.shouldRetry(tries, e, deadline): 5888 tries += 1 5889 time.sleep( 5890 self.parent.exponentialBackoff(tries, deadline)) 5891 continue 5892 raise plumbing.convert_error_to_porcelain(e) from e 5893 tries = 0 5894 for plumbing_item in plumbing_response.history: 5895 yield plumbing.convert_role_history_to_porcelain( 5896 plumbing_item) 5897 if plumbing_response.meta.next_cursor == '': 5898 break 5899 req.meta.cursor = plumbing_response.meta.next_cursor 5900 5901 return generator(self, req) 5902 5903 5904class SecretStores: 5905 ''' 5906 SecretStores are servers where resource secrets (passwords, keys) are stored. 5907 See: 5908 `strongdm.models.ActiveDirectoryStore` 5909 `strongdm.models.AWSStore` 5910 `strongdm.models.AWSCertX509Store` 5911 `strongdm.models.AzureStore` 5912 `strongdm.models.CyberarkConjurStore` 5913 `strongdm.models.CyberarkPAMStore` 5914 `strongdm.models.CyberarkPAMExperimentalStore` 5915 `strongdm.models.DelineaStore` 5916 `strongdm.models.GCPStore` 5917 `strongdm.models.GCPCertX509Store` 5918 `strongdm.models.KeyfactorSSHStore` 5919 `strongdm.models.KeyfactorX509Store` 5920 `strongdm.models.VaultAppRoleStore` 5921 `strongdm.models.VaultAppRoleCertSSHStore` 5922 `strongdm.models.VaultAppRoleCertX509Store` 5923 `strongdm.models.VaultAWSEC2Store` 5924 `strongdm.models.VaultAWSIAMStore` 5925 `strongdm.models.VaultTLSStore` 5926 `strongdm.models.VaultTLSCertSSHStore` 5927 `strongdm.models.VaultTLSCertX509Store` 5928 `strongdm.models.VaultTokenStore` 5929 `strongdm.models.VaultTokenCertSSHStore` 5930 `strongdm.models.VaultTokenCertX509Store` 5931 ''' 5932 def __init__(self, channel, client): 5933 self.parent = client 5934 self.stub = SecretStoresStub(channel) 5935 5936 def create(self, secret_store, timeout=None): 5937 deadline = None if timeout is None else time.time() + timeout 5938 req = SecretStoreCreateRequest() 5939 5940 if secret_store is not None: 5941 req.secret_store.CopyFrom( 5942 plumbing.convert_secret_store_to_plumbing(secret_store)) 5943 tries = 0 5944 plumbing_response = None 5945 while True: 5946 t = None if deadline is None else deadline - time.time() 5947 try: 5948 plumbing_response = self.stub.Create( 5949 req, 5950 metadata=self.parent.get_metadata('SecretStores.Create', 5951 req), 5952 timeout=t) 5953 except Exception as e: 5954 if self.parent.shouldRetry(tries, e, deadline): 5955 tries += 1 5956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5957 continue 5958 raise plumbing.convert_error_to_porcelain(e) from e 5959 break 5960 5961 resp = models.SecretStoreCreateResponse() 5962 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5963 plumbing_response.meta) 5964 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5965 plumbing_response.rate_limit) 5966 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5967 plumbing_response.secret_store) 5968 return resp 5969 5970 def get(self, id, timeout=None): 5971 ''' 5972 Get reads one SecretStore by ID. 5973 ''' 5974 deadline = None if timeout is None else time.time() + timeout 5975 req = SecretStoreGetRequest() 5976 if self.parent.snapshot_datetime is not None: 5977 req.meta.CopyFrom(GetRequestMetadata()) 5978 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5979 5980 req.id = (id) 5981 tries = 0 5982 plumbing_response = None 5983 while True: 5984 t = None if deadline is None else deadline - time.time() 5985 try: 5986 plumbing_response = self.stub.Get( 5987 req, 5988 metadata=self.parent.get_metadata('SecretStores.Get', req), 5989 timeout=t) 5990 except Exception as e: 5991 if self.parent.shouldRetry(tries, e, deadline): 5992 tries += 1 5993 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5994 continue 5995 raise plumbing.convert_error_to_porcelain(e) from e 5996 break 5997 5998 resp = models.SecretStoreGetResponse() 5999 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6000 plumbing_response.meta) 6001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6002 plumbing_response.rate_limit) 6003 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6004 plumbing_response.secret_store) 6005 return resp 6006 6007 def update(self, secret_store, timeout=None): 6008 ''' 6009 Update replaces all the fields of a SecretStore by ID. 6010 ''' 6011 deadline = None if timeout is None else time.time() + timeout 6012 req = SecretStoreUpdateRequest() 6013 6014 if secret_store is not None: 6015 req.secret_store.CopyFrom( 6016 plumbing.convert_secret_store_to_plumbing(secret_store)) 6017 tries = 0 6018 plumbing_response = None 6019 while True: 6020 t = None if deadline is None else deadline - time.time() 6021 try: 6022 plumbing_response = self.stub.Update( 6023 req, 6024 metadata=self.parent.get_metadata('SecretStores.Update', 6025 req), 6026 timeout=t) 6027 except Exception as e: 6028 if self.parent.shouldRetry(tries, e, deadline): 6029 tries += 1 6030 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6031 continue 6032 raise plumbing.convert_error_to_porcelain(e) from e 6033 break 6034 6035 resp = models.SecretStoreUpdateResponse() 6036 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6037 plumbing_response.meta) 6038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6039 plumbing_response.rate_limit) 6040 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6041 plumbing_response.secret_store) 6042 return resp 6043 6044 def delete(self, id, timeout=None): 6045 ''' 6046 Delete removes a SecretStore by ID. 6047 ''' 6048 deadline = None if timeout is None else time.time() + timeout 6049 req = SecretStoreDeleteRequest() 6050 6051 req.id = (id) 6052 tries = 0 6053 plumbing_response = None 6054 while True: 6055 t = None if deadline is None else deadline - time.time() 6056 try: 6057 plumbing_response = self.stub.Delete( 6058 req, 6059 metadata=self.parent.get_metadata('SecretStores.Delete', 6060 req), 6061 timeout=t) 6062 except Exception as e: 6063 if self.parent.shouldRetry(tries, e, deadline): 6064 tries += 1 6065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6066 continue 6067 raise plumbing.convert_error_to_porcelain(e) from e 6068 break 6069 6070 resp = models.SecretStoreDeleteResponse() 6071 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6072 plumbing_response.meta) 6073 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6074 plumbing_response.rate_limit) 6075 return resp 6076 6077 def list(self, filter, *args, timeout=None): 6078 ''' 6079 List gets a list of SecretStores matching a given set of criteria. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = SecretStoreListRequest() 6083 req.meta.CopyFrom(ListRequestMetadata()) 6084 if self.parent.page_limit > 0: 6085 req.meta.limit = self.parent.page_limit 6086 if self.parent.snapshot_datetime is not None: 6087 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6088 6089 req.filter = plumbing.quote_filter_args(filter, *args) 6090 6091 def generator(svc, req): 6092 tries = 0 6093 while True: 6094 t = None if deadline is None else deadline - time.time() 6095 try: 6096 plumbing_response = svc.stub.List( 6097 req, 6098 metadata=svc.parent.get_metadata( 6099 'SecretStores.List', req), 6100 timeout=t) 6101 except Exception as e: 6102 if self.parent.shouldRetry(tries, e, deadline): 6103 tries += 1 6104 time.sleep( 6105 self.parent.exponentialBackoff(tries, deadline)) 6106 continue 6107 raise plumbing.convert_error_to_porcelain(e) from e 6108 tries = 0 6109 for plumbing_item in plumbing_response.secret_stores: 6110 yield plumbing.convert_secret_store_to_porcelain( 6111 plumbing_item) 6112 if plumbing_response.meta.next_cursor == '': 6113 break 6114 req.meta.cursor = plumbing_response.meta.next_cursor 6115 6116 return generator(self, req) 6117 6118 6119class SnapshotSecretStores: 6120 ''' 6121 SnapshotSecretStores exposes the read only methods of the SecretStores 6122 service for historical queries. 6123 ''' 6124 def __init__(self, secret_stores): 6125 self.secret_stores = secret_stores 6126 6127 def get(self, id, timeout=None): 6128 ''' 6129 Get reads one SecretStore by ID. 6130 ''' 6131 return self.secret_stores.get(id, timeout=timeout) 6132 6133 def list(self, filter, *args, timeout=None): 6134 ''' 6135 List gets a list of SecretStores matching a given set of criteria. 6136 ''' 6137 return self.secret_stores.list(filter, *args, timeout=timeout) 6138 6139 6140class SecretEngines: 6141 ''' 6142 6143 See: 6144 `strongdm.models.ActiveDirectoryEngine` 6145 `strongdm.models.KeyValueEngine` 6146 ''' 6147 def __init__(self, channel, client): 6148 self.parent = client 6149 self.stub = SecretEnginesStub(channel) 6150 6151 def list(self, filter, *args, timeout=None): 6152 ''' 6153 List returns a list of Secret Engines 6154 ''' 6155 deadline = None if timeout is None else time.time() + timeout 6156 req = SecretEngineListRequest() 6157 req.meta.CopyFrom(ListRequestMetadata()) 6158 if self.parent.page_limit > 0: 6159 req.meta.limit = self.parent.page_limit 6160 if self.parent.snapshot_datetime is not None: 6161 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6162 6163 req.filter = plumbing.quote_filter_args(filter, *args) 6164 6165 def generator(svc, req): 6166 tries = 0 6167 while True: 6168 t = None if deadline is None else deadline - time.time() 6169 try: 6170 plumbing_response = svc.stub.List( 6171 req, 6172 metadata=svc.parent.get_metadata( 6173 'SecretEngines.List', req), 6174 timeout=t) 6175 except Exception as e: 6176 if self.parent.shouldRetry(tries, e, deadline): 6177 tries += 1 6178 time.sleep( 6179 self.parent.exponentialBackoff(tries, deadline)) 6180 continue 6181 raise plumbing.convert_error_to_porcelain(e) from e 6182 tries = 0 6183 for plumbing_item in plumbing_response.secret_engines: 6184 yield plumbing.convert_secret_engine_to_porcelain( 6185 plumbing_item) 6186 if plumbing_response.meta.next_cursor == '': 6187 break 6188 req.meta.cursor = plumbing_response.meta.next_cursor 6189 6190 return generator(self, req) 6191 6192 def get(self, id, timeout=None): 6193 ''' 6194 Get returns a secret engine details 6195 ''' 6196 deadline = None if timeout is None else time.time() + timeout 6197 req = SecretEngineGetRequest() 6198 if self.parent.snapshot_datetime is not None: 6199 req.meta.CopyFrom(GetRequestMetadata()) 6200 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6201 6202 req.id = (id) 6203 tries = 0 6204 plumbing_response = None 6205 while True: 6206 t = None if deadline is None else deadline - time.time() 6207 try: 6208 plumbing_response = self.stub.Get( 6209 req, 6210 metadata=self.parent.get_metadata('SecretEngines.Get', 6211 req), 6212 timeout=t) 6213 except Exception as e: 6214 if self.parent.shouldRetry(tries, e, deadline): 6215 tries += 1 6216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6217 continue 6218 raise plumbing.convert_error_to_porcelain(e) from e 6219 break 6220 6221 resp = models.SecretEngineGetResponse() 6222 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6223 plumbing_response.meta) 6224 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6225 plumbing_response.rate_limit) 6226 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6227 plumbing_response.secret_engine) 6228 return resp 6229 6230 def create(self, secret_engine, timeout=None): 6231 ''' 6232 Create creates a secret engine 6233 ''' 6234 deadline = None if timeout is None else time.time() + timeout 6235 req = SecretEngineCreateRequest() 6236 6237 if secret_engine is not None: 6238 req.secret_engine.CopyFrom( 6239 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6240 tries = 0 6241 plumbing_response = None 6242 while True: 6243 t = None if deadline is None else deadline - time.time() 6244 try: 6245 plumbing_response = self.stub.Create( 6246 req, 6247 metadata=self.parent.get_metadata('SecretEngines.Create', 6248 req), 6249 timeout=t) 6250 except Exception as e: 6251 if self.parent.shouldRetry(tries, e, deadline): 6252 tries += 1 6253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6254 continue 6255 raise plumbing.convert_error_to_porcelain(e) from e 6256 break 6257 6258 resp = models.SecretEngineCreateResponse() 6259 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6260 plumbing_response.meta) 6261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6262 plumbing_response.rate_limit) 6263 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6264 plumbing_response.secret_engine) 6265 return resp 6266 6267 def update(self, secret_engine, timeout=None): 6268 ''' 6269 Update updates a secret engine 6270 ''' 6271 deadline = None if timeout is None else time.time() + timeout 6272 req = SecretEngineUpdateRequest() 6273 6274 if secret_engine is not None: 6275 req.secret_engine.CopyFrom( 6276 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6277 tries = 0 6278 plumbing_response = None 6279 while True: 6280 t = None if deadline is None else deadline - time.time() 6281 try: 6282 plumbing_response = self.stub.Update( 6283 req, 6284 metadata=self.parent.get_metadata('SecretEngines.Update', 6285 req), 6286 timeout=t) 6287 except Exception as e: 6288 if self.parent.shouldRetry(tries, e, deadline): 6289 tries += 1 6290 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6291 continue 6292 raise plumbing.convert_error_to_porcelain(e) from e 6293 break 6294 6295 resp = models.SecretEngineUpdateResponse() 6296 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6297 plumbing_response.meta) 6298 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6299 plumbing_response.rate_limit) 6300 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6301 plumbing_response.secret_engine) 6302 return resp 6303 6304 def delete(self, id, timeout=None): 6305 ''' 6306 Delete deletes a secret engine 6307 ''' 6308 deadline = None if timeout is None else time.time() + timeout 6309 req = SecretEngineDeleteRequest() 6310 6311 req.id = (id) 6312 tries = 0 6313 plumbing_response = None 6314 while True: 6315 t = None if deadline is None else deadline - time.time() 6316 try: 6317 plumbing_response = self.stub.Delete( 6318 req, 6319 metadata=self.parent.get_metadata('SecretEngines.Delete', 6320 req), 6321 timeout=t) 6322 except Exception as e: 6323 if self.parent.shouldRetry(tries, e, deadline): 6324 tries += 1 6325 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6326 continue 6327 raise plumbing.convert_error_to_porcelain(e) from e 6328 break 6329 6330 resp = models.SecretEngineDeleteResponse() 6331 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6332 plumbing_response.rate_limit) 6333 return resp 6334 6335 def list_secret_stores(self, filter, *args, timeout=None): 6336 ''' 6337 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6338 for Secret Engine 6339 ''' 6340 deadline = None if timeout is None else time.time() + timeout 6341 req = SecretStoreListRequest() 6342 req.meta.CopyFrom(ListRequestMetadata()) 6343 if self.parent.page_limit > 0: 6344 req.meta.limit = self.parent.page_limit 6345 if self.parent.snapshot_datetime is not None: 6346 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6347 6348 req.filter = plumbing.quote_filter_args(filter, *args) 6349 6350 def generator(svc, req): 6351 tries = 0 6352 while True: 6353 t = None if deadline is None else deadline - time.time() 6354 try: 6355 plumbing_response = svc.stub.ListSecretStores( 6356 req, 6357 metadata=svc.parent.get_metadata( 6358 'SecretEngines.ListSecretStores', req), 6359 timeout=t) 6360 except Exception as e: 6361 if self.parent.shouldRetry(tries, e, deadline): 6362 tries += 1 6363 time.sleep( 6364 self.parent.exponentialBackoff(tries, deadline)) 6365 continue 6366 raise plumbing.convert_error_to_porcelain(e) from e 6367 tries = 0 6368 for plumbing_item in plumbing_response.secret_stores: 6369 yield plumbing.convert_secret_store_to_porcelain( 6370 plumbing_item) 6371 if plumbing_response.meta.next_cursor == '': 6372 break 6373 req.meta.cursor = plumbing_response.meta.next_cursor 6374 6375 return generator(self, req) 6376 6377 def generate_keys(self, secret_engine_id, timeout=None): 6378 ''' 6379 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6380 ''' 6381 deadline = None if timeout is None else time.time() + timeout 6382 req = GenerateKeysRequest() 6383 6384 req.secret_engine_id = (secret_engine_id) 6385 tries = 0 6386 plumbing_response = None 6387 while True: 6388 t = None if deadline is None else deadline - time.time() 6389 try: 6390 plumbing_response = self.stub.GenerateKeys( 6391 req, 6392 metadata=self.parent.get_metadata( 6393 'SecretEngines.GenerateKeys', req), 6394 timeout=t) 6395 except Exception as e: 6396 if self.parent.shouldRetry(tries, e, deadline): 6397 tries += 1 6398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6399 continue 6400 raise plumbing.convert_error_to_porcelain(e) from e 6401 break 6402 6403 resp = models.GenerateKeysResponse() 6404 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6405 plumbing_response.rate_limit) 6406 return resp 6407 6408 def healthcheck(self, secret_engine_id, timeout=None): 6409 ''' 6410 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6411 ''' 6412 deadline = None if timeout is None else time.time() + timeout 6413 req = HealthcheckRequest() 6414 6415 req.secret_engine_id = (secret_engine_id) 6416 tries = 0 6417 plumbing_response = None 6418 while True: 6419 t = None if deadline is None else deadline - time.time() 6420 try: 6421 plumbing_response = self.stub.Healthcheck( 6422 req, 6423 metadata=self.parent.get_metadata( 6424 'SecretEngines.Healthcheck', req), 6425 timeout=t) 6426 except Exception as e: 6427 if self.parent.shouldRetry(tries, e, deadline): 6428 tries += 1 6429 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6430 continue 6431 raise plumbing.convert_error_to_porcelain(e) from e 6432 break 6433 6434 resp = models.HealthcheckResponse() 6435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6436 plumbing_response.rate_limit) 6437 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6438 plumbing_response.status) 6439 return resp 6440 6441 def rotate(self, id, password_policy, timeout=None): 6442 ''' 6443 Rotate rotates secret engine's credentials 6444 ''' 6445 deadline = None if timeout is None else time.time() + timeout 6446 req = SecretEngineRotateRequest() 6447 6448 req.id = (id) 6449 if password_policy is not None: 6450 req.password_policy.CopyFrom( 6451 plumbing.convert_secret_engine_password_policy_to_plumbing( 6452 password_policy)) 6453 tries = 0 6454 plumbing_response = None 6455 while True: 6456 t = None if deadline is None else deadline - time.time() 6457 try: 6458 plumbing_response = self.stub.Rotate( 6459 req, 6460 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6461 req), 6462 timeout=t) 6463 except Exception as e: 6464 if self.parent.shouldRetry(tries, e, deadline): 6465 tries += 1 6466 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6467 continue 6468 raise plumbing.convert_error_to_porcelain(e) from e 6469 break 6470 6471 resp = models.SecretEngineRotateResponse() 6472 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6473 plumbing_response.rate_limit) 6474 return resp 6475 6476 6477class SecretStoreHealths: 6478 ''' 6479 SecretStoreHealths exposes health states for secret stores. 6480 See `strongdm.models.SecretStoreHealth`. 6481 ''' 6482 def __init__(self, channel, client): 6483 self.parent = client 6484 self.stub = SecretStoreHealthsStub(channel) 6485 6486 def list(self, filter, *args, timeout=None): 6487 ''' 6488 List reports the health status of node to secret store pairs. 6489 ''' 6490 deadline = None if timeout is None else time.time() + timeout 6491 req = SecretStoreHealthListRequest() 6492 req.meta.CopyFrom(ListRequestMetadata()) 6493 if self.parent.page_limit > 0: 6494 req.meta.limit = self.parent.page_limit 6495 if self.parent.snapshot_datetime is not None: 6496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6497 6498 req.filter = plumbing.quote_filter_args(filter, *args) 6499 6500 def generator(svc, req): 6501 tries = 0 6502 while True: 6503 t = None if deadline is None else deadline - time.time() 6504 try: 6505 plumbing_response = svc.stub.List( 6506 req, 6507 metadata=svc.parent.get_metadata( 6508 'SecretStoreHealths.List', req), 6509 timeout=t) 6510 except Exception as e: 6511 if self.parent.shouldRetry(tries, e, deadline): 6512 tries += 1 6513 time.sleep( 6514 self.parent.exponentialBackoff(tries, deadline)) 6515 continue 6516 raise plumbing.convert_error_to_porcelain(e) from e 6517 tries = 0 6518 for plumbing_item in plumbing_response.secret_store_healths: 6519 yield plumbing.convert_secret_store_health_to_porcelain( 6520 plumbing_item) 6521 if plumbing_response.meta.next_cursor == '': 6522 break 6523 req.meta.cursor = plumbing_response.meta.next_cursor 6524 6525 return generator(self, req) 6526 6527 def healthcheck(self, secret_store_id, timeout=None): 6528 ''' 6529 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6530 to propagate across a large network of Nodes. The call will return immediately, and the 6531 updated health of the Secret Store can be retrieved via List. 6532 ''' 6533 deadline = None if timeout is None else time.time() + timeout 6534 req = SecretStoreHealthcheckRequest() 6535 6536 req.secret_store_id = (secret_store_id) 6537 tries = 0 6538 plumbing_response = None 6539 while True: 6540 t = None if deadline is None else deadline - time.time() 6541 try: 6542 plumbing_response = self.stub.Healthcheck( 6543 req, 6544 metadata=self.parent.get_metadata( 6545 'SecretStoreHealths.Healthcheck', req), 6546 timeout=t) 6547 except Exception as e: 6548 if self.parent.shouldRetry(tries, e, deadline): 6549 tries += 1 6550 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6551 continue 6552 raise plumbing.convert_error_to_porcelain(e) from e 6553 break 6554 6555 resp = models.SecretStoreHealthcheckResponse() 6556 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6557 plumbing_response.rate_limit) 6558 return resp 6559 6560 6561class SecretStoresHistory: 6562 ''' 6563 SecretStoresHistory records all changes to the state of a SecretStore. 6564 See `strongdm.models.SecretStoreHistory`. 6565 ''' 6566 def __init__(self, channel, client): 6567 self.parent = client 6568 self.stub = SecretStoresHistoryStub(channel) 6569 6570 def list(self, filter, *args, timeout=None): 6571 ''' 6572 List gets a list of SecretStoreHistory records matching a given set of criteria. 6573 ''' 6574 deadline = None if timeout is None else time.time() + timeout 6575 req = SecretStoreHistoryListRequest() 6576 req.meta.CopyFrom(ListRequestMetadata()) 6577 if self.parent.page_limit > 0: 6578 req.meta.limit = self.parent.page_limit 6579 if self.parent.snapshot_datetime is not None: 6580 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6581 6582 req.filter = plumbing.quote_filter_args(filter, *args) 6583 6584 def generator(svc, req): 6585 tries = 0 6586 while True: 6587 t = None if deadline is None else deadline - time.time() 6588 try: 6589 plumbing_response = svc.stub.List( 6590 req, 6591 metadata=svc.parent.get_metadata( 6592 'SecretStoresHistory.List', req), 6593 timeout=t) 6594 except Exception as e: 6595 if self.parent.shouldRetry(tries, e, deadline): 6596 tries += 1 6597 time.sleep( 6598 self.parent.exponentialBackoff(tries, deadline)) 6599 continue 6600 raise plumbing.convert_error_to_porcelain(e) from e 6601 tries = 0 6602 for plumbing_item in plumbing_response.history: 6603 yield plumbing.convert_secret_store_history_to_porcelain( 6604 plumbing_item) 6605 if plumbing_response.meta.next_cursor == '': 6606 break 6607 req.meta.cursor = plumbing_response.meta.next_cursor 6608 6609 return generator(self, req) 6610 6611 6612class WorkflowApprovers: 6613 ''' 6614 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6615 See `strongdm.models.WorkflowApprover`. 6616 ''' 6617 def __init__(self, channel, client): 6618 self.parent = client 6619 self.stub = WorkflowApproversStub(channel) 6620 6621 def create(self, workflow_approver, timeout=None): 6622 ''' 6623 Create creates a new workflow approver 6624 ''' 6625 deadline = None if timeout is None else time.time() + timeout 6626 req = WorkflowApproversCreateRequest() 6627 6628 if workflow_approver is not None: 6629 req.workflow_approver.CopyFrom( 6630 plumbing.convert_workflow_approver_to_plumbing( 6631 workflow_approver)) 6632 tries = 0 6633 plumbing_response = None 6634 while True: 6635 t = None if deadline is None else deadline - time.time() 6636 try: 6637 plumbing_response = self.stub.Create( 6638 req, 6639 metadata=self.parent.get_metadata( 6640 'WorkflowApprovers.Create', req), 6641 timeout=t) 6642 except Exception as e: 6643 if self.parent.shouldRetry(tries, e, deadline): 6644 tries += 1 6645 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6646 continue 6647 raise plumbing.convert_error_to_porcelain(e) from e 6648 break 6649 6650 resp = models.WorkflowApproversCreateResponse() 6651 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6652 plumbing_response.rate_limit) 6653 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6654 plumbing_response.workflow_approver) 6655 return resp 6656 6657 def get(self, id, timeout=None): 6658 ''' 6659 Get reads one workflow approver by ID. 6660 ''' 6661 deadline = None if timeout is None else time.time() + timeout 6662 req = WorkflowApproverGetRequest() 6663 if self.parent.snapshot_datetime is not None: 6664 req.meta.CopyFrom(GetRequestMetadata()) 6665 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6666 6667 req.id = (id) 6668 tries = 0 6669 plumbing_response = None 6670 while True: 6671 t = None if deadline is None else deadline - time.time() 6672 try: 6673 plumbing_response = self.stub.Get( 6674 req, 6675 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6676 req), 6677 timeout=t) 6678 except Exception as e: 6679 if self.parent.shouldRetry(tries, e, deadline): 6680 tries += 1 6681 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6682 continue 6683 raise plumbing.convert_error_to_porcelain(e) from e 6684 break 6685 6686 resp = models.WorkflowApproverGetResponse() 6687 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6688 plumbing_response.meta) 6689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6690 plumbing_response.rate_limit) 6691 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6692 plumbing_response.workflow_approver) 6693 return resp 6694 6695 def delete(self, id, timeout=None): 6696 ''' 6697 Delete deletes a workflow approver 6698 ''' 6699 deadline = None if timeout is None else time.time() + timeout 6700 req = WorkflowApproversDeleteRequest() 6701 6702 req.id = (id) 6703 tries = 0 6704 plumbing_response = None 6705 while True: 6706 t = None if deadline is None else deadline - time.time() 6707 try: 6708 plumbing_response = self.stub.Delete( 6709 req, 6710 metadata=self.parent.get_metadata( 6711 'WorkflowApprovers.Delete', req), 6712 timeout=t) 6713 except Exception as e: 6714 if self.parent.shouldRetry(tries, e, deadline): 6715 tries += 1 6716 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6717 continue 6718 raise plumbing.convert_error_to_porcelain(e) from e 6719 break 6720 6721 resp = models.WorkflowApproversDeleteResponse() 6722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6723 plumbing_response.rate_limit) 6724 return resp 6725 6726 def list(self, filter, *args, timeout=None): 6727 ''' 6728 Lists existing workflow approvers. 6729 ''' 6730 deadline = None if timeout is None else time.time() + timeout 6731 req = WorkflowApproversListRequest() 6732 req.meta.CopyFrom(ListRequestMetadata()) 6733 if self.parent.page_limit > 0: 6734 req.meta.limit = self.parent.page_limit 6735 if self.parent.snapshot_datetime is not None: 6736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6737 6738 req.filter = plumbing.quote_filter_args(filter, *args) 6739 6740 def generator(svc, req): 6741 tries = 0 6742 while True: 6743 t = None if deadline is None else deadline - time.time() 6744 try: 6745 plumbing_response = svc.stub.List( 6746 req, 6747 metadata=svc.parent.get_metadata( 6748 'WorkflowApprovers.List', req), 6749 timeout=t) 6750 except Exception as e: 6751 if self.parent.shouldRetry(tries, e, deadline): 6752 tries += 1 6753 time.sleep( 6754 self.parent.exponentialBackoff(tries, deadline)) 6755 continue 6756 raise plumbing.convert_error_to_porcelain(e) from e 6757 tries = 0 6758 for plumbing_item in plumbing_response.workflow_approvers: 6759 yield plumbing.convert_workflow_approver_to_porcelain( 6760 plumbing_item) 6761 if plumbing_response.meta.next_cursor == '': 6762 break 6763 req.meta.cursor = plumbing_response.meta.next_cursor 6764 6765 return generator(self, req) 6766 6767 6768class SnapshotWorkflowApprovers: 6769 ''' 6770 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6771 service for historical queries. 6772 ''' 6773 def __init__(self, workflow_approvers): 6774 self.workflow_approvers = workflow_approvers 6775 6776 def get(self, id, timeout=None): 6777 ''' 6778 Get reads one workflow approver by ID. 6779 ''' 6780 return self.workflow_approvers.get(id, timeout=timeout) 6781 6782 def list(self, filter, *args, timeout=None): 6783 ''' 6784 Lists existing workflow approvers. 6785 ''' 6786 return self.workflow_approvers.list(filter, *args, timeout=timeout) 6787 6788 6789class WorkflowApproversHistory: 6790 ''' 6791 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6792 See `strongdm.models.WorkflowApproverHistory`. 6793 ''' 6794 def __init__(self, channel, client): 6795 self.parent = client 6796 self.stub = WorkflowApproversHistoryStub(channel) 6797 6798 def list(self, filter, *args, timeout=None): 6799 ''' 6800 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6801 ''' 6802 deadline = None if timeout is None else time.time() + timeout 6803 req = WorkflowApproversHistoryListRequest() 6804 req.meta.CopyFrom(ListRequestMetadata()) 6805 if self.parent.page_limit > 0: 6806 req.meta.limit = self.parent.page_limit 6807 if self.parent.snapshot_datetime is not None: 6808 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6809 6810 req.filter = plumbing.quote_filter_args(filter, *args) 6811 6812 def generator(svc, req): 6813 tries = 0 6814 while True: 6815 t = None if deadline is None else deadline - time.time() 6816 try: 6817 plumbing_response = svc.stub.List( 6818 req, 6819 metadata=svc.parent.get_metadata( 6820 'WorkflowApproversHistory.List', req), 6821 timeout=t) 6822 except Exception as e: 6823 if self.parent.shouldRetry(tries, e, deadline): 6824 tries += 1 6825 time.sleep( 6826 self.parent.exponentialBackoff(tries, deadline)) 6827 continue 6828 raise plumbing.convert_error_to_porcelain(e) from e 6829 tries = 0 6830 for plumbing_item in plumbing_response.history: 6831 yield plumbing.convert_workflow_approver_history_to_porcelain( 6832 plumbing_item) 6833 if plumbing_response.meta.next_cursor == '': 6834 break 6835 req.meta.cursor = plumbing_response.meta.next_cursor 6836 6837 return generator(self, req) 6838 6839 6840class WorkflowRoles: 6841 ''' 6842 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6843 to request access to a resource via the workflow. 6844 See `strongdm.models.WorkflowRole`. 6845 ''' 6846 def __init__(self, channel, client): 6847 self.parent = client 6848 self.stub = WorkflowRolesStub(channel) 6849 6850 def create(self, workflow_role, timeout=None): 6851 ''' 6852 Create creates a new workflow role 6853 ''' 6854 deadline = None if timeout is None else time.time() + timeout 6855 req = WorkflowRolesCreateRequest() 6856 6857 if workflow_role is not None: 6858 req.workflow_role.CopyFrom( 6859 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6860 tries = 0 6861 plumbing_response = None 6862 while True: 6863 t = None if deadline is None else deadline - time.time() 6864 try: 6865 plumbing_response = self.stub.Create( 6866 req, 6867 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6868 req), 6869 timeout=t) 6870 except Exception as e: 6871 if self.parent.shouldRetry(tries, e, deadline): 6872 tries += 1 6873 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6874 continue 6875 raise plumbing.convert_error_to_porcelain(e) from e 6876 break 6877 6878 resp = models.WorkflowRolesCreateResponse() 6879 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6880 plumbing_response.rate_limit) 6881 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6882 plumbing_response.workflow_role) 6883 return resp 6884 6885 def get(self, id, timeout=None): 6886 ''' 6887 Get reads one workflow role by ID. 6888 ''' 6889 deadline = None if timeout is None else time.time() + timeout 6890 req = WorkflowRoleGetRequest() 6891 if self.parent.snapshot_datetime is not None: 6892 req.meta.CopyFrom(GetRequestMetadata()) 6893 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6894 6895 req.id = (id) 6896 tries = 0 6897 plumbing_response = None 6898 while True: 6899 t = None if deadline is None else deadline - time.time() 6900 try: 6901 plumbing_response = self.stub.Get( 6902 req, 6903 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6904 req), 6905 timeout=t) 6906 except Exception as e: 6907 if self.parent.shouldRetry(tries, e, deadline): 6908 tries += 1 6909 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6910 continue 6911 raise plumbing.convert_error_to_porcelain(e) from e 6912 break 6913 6914 resp = models.WorkflowRoleGetResponse() 6915 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6916 plumbing_response.meta) 6917 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6918 plumbing_response.rate_limit) 6919 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6920 plumbing_response.workflow_role) 6921 return resp 6922 6923 def delete(self, id, timeout=None): 6924 ''' 6925 Delete deletes a workflow role 6926 ''' 6927 deadline = None if timeout is None else time.time() + timeout 6928 req = WorkflowRolesDeleteRequest() 6929 6930 req.id = (id) 6931 tries = 0 6932 plumbing_response = None 6933 while True: 6934 t = None if deadline is None else deadline - time.time() 6935 try: 6936 plumbing_response = self.stub.Delete( 6937 req, 6938 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6939 req), 6940 timeout=t) 6941 except Exception as e: 6942 if self.parent.shouldRetry(tries, e, deadline): 6943 tries += 1 6944 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6945 continue 6946 raise plumbing.convert_error_to_porcelain(e) from e 6947 break 6948 6949 resp = models.WorkflowRolesDeleteResponse() 6950 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6951 plumbing_response.rate_limit) 6952 return resp 6953 6954 def list(self, filter, *args, timeout=None): 6955 ''' 6956 Lists existing workflow roles. 6957 ''' 6958 deadline = None if timeout is None else time.time() + timeout 6959 req = WorkflowRolesListRequest() 6960 req.meta.CopyFrom(ListRequestMetadata()) 6961 if self.parent.page_limit > 0: 6962 req.meta.limit = self.parent.page_limit 6963 if self.parent.snapshot_datetime is not None: 6964 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6965 6966 req.filter = plumbing.quote_filter_args(filter, *args) 6967 6968 def generator(svc, req): 6969 tries = 0 6970 while True: 6971 t = None if deadline is None else deadline - time.time() 6972 try: 6973 plumbing_response = svc.stub.List( 6974 req, 6975 metadata=svc.parent.get_metadata( 6976 'WorkflowRoles.List', req), 6977 timeout=t) 6978 except Exception as e: 6979 if self.parent.shouldRetry(tries, e, deadline): 6980 tries += 1 6981 time.sleep( 6982 self.parent.exponentialBackoff(tries, deadline)) 6983 continue 6984 raise plumbing.convert_error_to_porcelain(e) from e 6985 tries = 0 6986 for plumbing_item in plumbing_response.workflow_role: 6987 yield plumbing.convert_workflow_role_to_porcelain( 6988 plumbing_item) 6989 if plumbing_response.meta.next_cursor == '': 6990 break 6991 req.meta.cursor = plumbing_response.meta.next_cursor 6992 6993 return generator(self, req) 6994 6995 6996class SnapshotWorkflowRoles: 6997 ''' 6998 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 6999 service for historical queries. 7000 ''' 7001 def __init__(self, workflow_roles): 7002 self.workflow_roles = workflow_roles 7003 7004 def get(self, id, timeout=None): 7005 ''' 7006 Get reads one workflow role by ID. 7007 ''' 7008 return self.workflow_roles.get(id, timeout=timeout) 7009 7010 def list(self, filter, *args, timeout=None): 7011 ''' 7012 Lists existing workflow roles. 7013 ''' 7014 return self.workflow_roles.list(filter, *args, timeout=timeout) 7015 7016 7017class WorkflowRolesHistory: 7018 ''' 7019 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7020 See `strongdm.models.WorkflowRoleHistory`. 7021 ''' 7022 def __init__(self, channel, client): 7023 self.parent = client 7024 self.stub = WorkflowRolesHistoryStub(channel) 7025 7026 def list(self, filter, *args, timeout=None): 7027 ''' 7028 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7029 ''' 7030 deadline = None if timeout is None else time.time() + timeout 7031 req = WorkflowRolesHistoryListRequest() 7032 req.meta.CopyFrom(ListRequestMetadata()) 7033 if self.parent.page_limit > 0: 7034 req.meta.limit = self.parent.page_limit 7035 if self.parent.snapshot_datetime is not None: 7036 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7037 7038 req.filter = plumbing.quote_filter_args(filter, *args) 7039 7040 def generator(svc, req): 7041 tries = 0 7042 while True: 7043 t = None if deadline is None else deadline - time.time() 7044 try: 7045 plumbing_response = svc.stub.List( 7046 req, 7047 metadata=svc.parent.get_metadata( 7048 'WorkflowRolesHistory.List', req), 7049 timeout=t) 7050 except Exception as e: 7051 if self.parent.shouldRetry(tries, e, deadline): 7052 tries += 1 7053 time.sleep( 7054 self.parent.exponentialBackoff(tries, deadline)) 7055 continue 7056 raise plumbing.convert_error_to_porcelain(e) from e 7057 tries = 0 7058 for plumbing_item in plumbing_response.history: 7059 yield plumbing.convert_workflow_role_history_to_porcelain( 7060 plumbing_item) 7061 if plumbing_response.meta.next_cursor == '': 7062 break 7063 req.meta.cursor = plumbing_response.meta.next_cursor 7064 7065 return generator(self, req) 7066 7067 7068class Workflows: 7069 ''' 7070 Workflows are the collection of rules that define the resources to which access can be requested, 7071 the users that can request that access, and the mechanism for approving those requests which can either 7072 be automatic approval or a set of users authorized to approve the requests. 7073 See `strongdm.models.Workflow`. 7074 ''' 7075 def __init__(self, channel, client): 7076 self.parent = client 7077 self.stub = WorkflowsStub(channel) 7078 7079 def create(self, workflow, timeout=None): 7080 ''' 7081 Create creates a new workflow and requires a name for the workflow. 7082 ''' 7083 deadline = None if timeout is None else time.time() + timeout 7084 req = WorkflowCreateRequest() 7085 7086 if workflow is not None: 7087 req.workflow.CopyFrom( 7088 plumbing.convert_workflow_to_plumbing(workflow)) 7089 tries = 0 7090 plumbing_response = None 7091 while True: 7092 t = None if deadline is None else deadline - time.time() 7093 try: 7094 plumbing_response = self.stub.Create( 7095 req, 7096 metadata=self.parent.get_metadata('Workflows.Create', req), 7097 timeout=t) 7098 except Exception as e: 7099 if self.parent.shouldRetry(tries, e, deadline): 7100 tries += 1 7101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7102 continue 7103 raise plumbing.convert_error_to_porcelain(e) from e 7104 break 7105 7106 resp = models.WorkflowCreateResponse() 7107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7108 plumbing_response.rate_limit) 7109 resp.workflow = plumbing.convert_workflow_to_porcelain( 7110 plumbing_response.workflow) 7111 return resp 7112 7113 def get(self, id, timeout=None): 7114 ''' 7115 Get reads one workflow by ID. 7116 ''' 7117 deadline = None if timeout is None else time.time() + timeout 7118 req = WorkflowGetRequest() 7119 if self.parent.snapshot_datetime is not None: 7120 req.meta.CopyFrom(GetRequestMetadata()) 7121 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7122 7123 req.id = (id) 7124 tries = 0 7125 plumbing_response = None 7126 while True: 7127 t = None if deadline is None else deadline - time.time() 7128 try: 7129 plumbing_response = self.stub.Get( 7130 req, 7131 metadata=self.parent.get_metadata('Workflows.Get', req), 7132 timeout=t) 7133 except Exception as e: 7134 if self.parent.shouldRetry(tries, e, deadline): 7135 tries += 1 7136 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7137 continue 7138 raise plumbing.convert_error_to_porcelain(e) from e 7139 break 7140 7141 resp = models.WorkflowGetResponse() 7142 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7143 plumbing_response.meta) 7144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7145 plumbing_response.rate_limit) 7146 resp.workflow = plumbing.convert_workflow_to_porcelain( 7147 plumbing_response.workflow) 7148 return resp 7149 7150 def delete(self, id, timeout=None): 7151 ''' 7152 Delete deletes an existing workflow. 7153 ''' 7154 deadline = None if timeout is None else time.time() + timeout 7155 req = WorkflowDeleteRequest() 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.Delete( 7164 req, 7165 metadata=self.parent.get_metadata('Workflows.Delete', 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.WorkflowDeleteResponse() 7176 resp.id = (plumbing_response.id) 7177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7178 plumbing_response.rate_limit) 7179 return resp 7180 7181 def update(self, workflow, timeout=None): 7182 ''' 7183 Update updates an existing workflow. 7184 ''' 7185 deadline = None if timeout is None else time.time() + timeout 7186 req = WorkflowUpdateRequest() 7187 7188 if workflow is not None: 7189 req.workflow.CopyFrom( 7190 plumbing.convert_workflow_to_plumbing(workflow)) 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.Update( 7197 req, 7198 metadata=self.parent.get_metadata('Workflows.Update', 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.WorkflowUpdateResponse() 7209 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7210 plumbing_response.rate_limit) 7211 resp.workflow = plumbing.convert_workflow_to_porcelain( 7212 plumbing_response.workflow) 7213 return resp 7214 7215 def list(self, filter, *args, timeout=None): 7216 ''' 7217 Lists existing workflows. 7218 ''' 7219 deadline = None if timeout is None else time.time() + timeout 7220 req = WorkflowListRequest() 7221 req.meta.CopyFrom(ListRequestMetadata()) 7222 if self.parent.page_limit > 0: 7223 req.meta.limit = self.parent.page_limit 7224 if self.parent.snapshot_datetime is not None: 7225 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7226 7227 req.filter = plumbing.quote_filter_args(filter, *args) 7228 7229 def generator(svc, req): 7230 tries = 0 7231 while True: 7232 t = None if deadline is None else deadline - time.time() 7233 try: 7234 plumbing_response = svc.stub.List( 7235 req, 7236 metadata=svc.parent.get_metadata( 7237 'Workflows.List', req), 7238 timeout=t) 7239 except Exception as e: 7240 if self.parent.shouldRetry(tries, e, deadline): 7241 tries += 1 7242 time.sleep( 7243 self.parent.exponentialBackoff(tries, deadline)) 7244 continue 7245 raise plumbing.convert_error_to_porcelain(e) from e 7246 tries = 0 7247 for plumbing_item in plumbing_response.workflows: 7248 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7249 if plumbing_response.meta.next_cursor == '': 7250 break 7251 req.meta.cursor = plumbing_response.meta.next_cursor 7252 7253 return generator(self, req) 7254 7255 7256class SnapshotWorkflows: 7257 ''' 7258 SnapshotWorkflows exposes the read only methods of the Workflows 7259 service for historical queries. 7260 ''' 7261 def __init__(self, workflows): 7262 self.workflows = workflows 7263 7264 def get(self, id, timeout=None): 7265 ''' 7266 Get reads one workflow by ID. 7267 ''' 7268 return self.workflows.get(id, timeout=timeout) 7269 7270 def list(self, filter, *args, timeout=None): 7271 ''' 7272 Lists existing workflows. 7273 ''' 7274 return self.workflows.list(filter, *args, timeout=timeout) 7275 7276 7277class WorkflowsHistory: 7278 ''' 7279 WorkflowsHistory provides records of all changes to the state of a Workflow. 7280 See `strongdm.models.WorkflowHistory`. 7281 ''' 7282 def __init__(self, channel, client): 7283 self.parent = client 7284 self.stub = WorkflowsHistoryStub(channel) 7285 7286 def list(self, filter, *args, timeout=None): 7287 ''' 7288 List gets a list of WorkflowHistory records matching a given set of criteria. 7289 ''' 7290 deadline = None if timeout is None else time.time() + timeout 7291 req = WorkflowHistoryListRequest() 7292 req.meta.CopyFrom(ListRequestMetadata()) 7293 if self.parent.page_limit > 0: 7294 req.meta.limit = self.parent.page_limit 7295 if self.parent.snapshot_datetime is not None: 7296 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7297 7298 req.filter = plumbing.quote_filter_args(filter, *args) 7299 7300 def generator(svc, req): 7301 tries = 0 7302 while True: 7303 t = None if deadline is None else deadline - time.time() 7304 try: 7305 plumbing_response = svc.stub.List( 7306 req, 7307 metadata=svc.parent.get_metadata( 7308 'WorkflowsHistory.List', req), 7309 timeout=t) 7310 except Exception as e: 7311 if self.parent.shouldRetry(tries, e, deadline): 7312 tries += 1 7313 time.sleep( 7314 self.parent.exponentialBackoff(tries, deadline)) 7315 continue 7316 raise plumbing.convert_error_to_porcelain(e) from e 7317 tries = 0 7318 for plumbing_item in plumbing_response.history: 7319 yield plumbing.convert_workflow_history_to_porcelain( 7320 plumbing_item) 7321 if plumbing_response.meta.next_cursor == '': 7322 break 7323 req.meta.cursor = plumbing_response.meta.next_cursor 7324 7325 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
HealthChecks:
2185class HealthChecks: 2186 ''' 2187 HealthChecks lists the last healthcheck between each node and resource. 2188 Note the unconventional capitalization here is to prevent having a collision with GRPC 2189 See `strongdm.models.Healthcheck`. 2190 ''' 2191 def __init__(self, channel, client): 2192 self.parent = client 2193 self.stub = HealthChecksStub(channel) 2194 2195 def list(self, filter, *args, timeout=None): 2196 ''' 2197 List gets a list of Healthchecks matching a given set of criteria. 2198 ''' 2199 deadline = None if timeout is None else time.time() + timeout 2200 req = HealthcheckListRequest() 2201 req.meta.CopyFrom(ListRequestMetadata()) 2202 if self.parent.page_limit > 0: 2203 req.meta.limit = self.parent.page_limit 2204 if self.parent.snapshot_datetime is not None: 2205 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2206 2207 req.filter = plumbing.quote_filter_args(filter, *args) 2208 2209 def generator(svc, req): 2210 tries = 0 2211 while True: 2212 t = None if deadline is None else deadline - time.time() 2213 try: 2214 plumbing_response = svc.stub.List( 2215 req, 2216 metadata=svc.parent.get_metadata( 2217 'HealthChecks.List', req), 2218 timeout=t) 2219 except Exception as e: 2220 if self.parent.shouldRetry(tries, e, deadline): 2221 tries += 1 2222 time.sleep( 2223 self.parent.exponentialBackoff(tries, deadline)) 2224 continue 2225 raise plumbing.convert_error_to_porcelain(e) from e 2226 tries = 0 2227 for plumbing_item in plumbing_response.healthchecks: 2228 yield plumbing.convert_healthcheck_to_porcelain( 2229 plumbing_item) 2230 if plumbing_response.meta.next_cursor == '': 2231 break 2232 req.meta.cursor = plumbing_response.meta.next_cursor 2233 2234 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)
2195 def list(self, filter, *args, timeout=None): 2196 ''' 2197 List gets a list of Healthchecks matching a given set of criteria. 2198 ''' 2199 deadline = None if timeout is None else time.time() + timeout 2200 req = HealthcheckListRequest() 2201 req.meta.CopyFrom(ListRequestMetadata()) 2202 if self.parent.page_limit > 0: 2203 req.meta.limit = self.parent.page_limit 2204 if self.parent.snapshot_datetime is not None: 2205 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2206 2207 req.filter = plumbing.quote_filter_args(filter, *args) 2208 2209 def generator(svc, req): 2210 tries = 0 2211 while True: 2212 t = None if deadline is None else deadline - time.time() 2213 try: 2214 plumbing_response = svc.stub.List( 2215 req, 2216 metadata=svc.parent.get_metadata( 2217 'HealthChecks.List', req), 2218 timeout=t) 2219 except Exception as e: 2220 if self.parent.shouldRetry(tries, e, deadline): 2221 tries += 1 2222 time.sleep( 2223 self.parent.exponentialBackoff(tries, deadline)) 2224 continue 2225 raise plumbing.convert_error_to_porcelain(e) from e 2226 tries = 0 2227 for plumbing_item in plumbing_response.healthchecks: 2228 yield plumbing.convert_healthcheck_to_porcelain( 2229 plumbing_item) 2230 if plumbing_response.meta.next_cursor == '': 2231 break 2232 req.meta.cursor = plumbing_response.meta.next_cursor 2233 2234 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
2237class IdentityAliases: 2238 ''' 2239 IdentityAliases assign an alias to an account within an IdentitySet. 2240 The alias is used as the username when connecting to a identity supported resource. 2241 See `strongdm.models.IdentityAlias`. 2242 ''' 2243 def __init__(self, channel, client): 2244 self.parent = client 2245 self.stub = IdentityAliasesStub(channel) 2246 2247 def create(self, identity_alias, timeout=None): 2248 ''' 2249 Create registers a new IdentityAlias. 2250 ''' 2251 deadline = None if timeout is None else time.time() + timeout 2252 req = IdentityAliasCreateRequest() 2253 2254 if identity_alias is not None: 2255 req.identity_alias.CopyFrom( 2256 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2257 tries = 0 2258 plumbing_response = None 2259 while True: 2260 t = None if deadline is None else deadline - time.time() 2261 try: 2262 plumbing_response = self.stub.Create( 2263 req, 2264 metadata=self.parent.get_metadata('IdentityAliases.Create', 2265 req), 2266 timeout=t) 2267 except Exception as e: 2268 if self.parent.shouldRetry(tries, e, deadline): 2269 tries += 1 2270 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2271 continue 2272 raise plumbing.convert_error_to_porcelain(e) from e 2273 break 2274 2275 resp = models.IdentityAliasCreateResponse() 2276 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2277 plumbing_response.identity_alias) 2278 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2279 plumbing_response.meta) 2280 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2281 plumbing_response.rate_limit) 2282 return resp 2283 2284 def get(self, id, timeout=None): 2285 ''' 2286 Get reads one IdentityAlias by ID. 2287 ''' 2288 deadline = None if timeout is None else time.time() + timeout 2289 req = IdentityAliasGetRequest() 2290 if self.parent.snapshot_datetime is not None: 2291 req.meta.CopyFrom(GetRequestMetadata()) 2292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2293 2294 req.id = (id) 2295 tries = 0 2296 plumbing_response = None 2297 while True: 2298 t = None if deadline is None else deadline - time.time() 2299 try: 2300 plumbing_response = self.stub.Get( 2301 req, 2302 metadata=self.parent.get_metadata('IdentityAliases.Get', 2303 req), 2304 timeout=t) 2305 except Exception as e: 2306 if self.parent.shouldRetry(tries, e, deadline): 2307 tries += 1 2308 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2309 continue 2310 raise plumbing.convert_error_to_porcelain(e) from e 2311 break 2312 2313 resp = models.IdentityAliasGetResponse() 2314 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2315 plumbing_response.identity_alias) 2316 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2317 plumbing_response.meta) 2318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2319 plumbing_response.rate_limit) 2320 return resp 2321 2322 def update(self, identity_alias, timeout=None): 2323 ''' 2324 Update replaces all the fields of a IdentityAlias by ID. 2325 ''' 2326 deadline = None if timeout is None else time.time() + timeout 2327 req = IdentityAliasUpdateRequest() 2328 2329 if identity_alias is not None: 2330 req.identity_alias.CopyFrom( 2331 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.Update( 2338 req, 2339 metadata=self.parent.get_metadata('IdentityAliases.Update', 2340 req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.IdentityAliasUpdateResponse() 2351 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2352 plumbing_response.identity_alias) 2353 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2354 plumbing_response.meta) 2355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2356 plumbing_response.rate_limit) 2357 return resp 2358 2359 def delete(self, id, timeout=None): 2360 ''' 2361 Delete removes a IdentityAlias by ID. 2362 ''' 2363 deadline = None if timeout is None else time.time() + timeout 2364 req = IdentityAliasDeleteRequest() 2365 2366 req.id = (id) 2367 tries = 0 2368 plumbing_response = None 2369 while True: 2370 t = None if deadline is None else deadline - time.time() 2371 try: 2372 plumbing_response = self.stub.Delete( 2373 req, 2374 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2375 req), 2376 timeout=t) 2377 except Exception as e: 2378 if self.parent.shouldRetry(tries, e, deadline): 2379 tries += 1 2380 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2381 continue 2382 raise plumbing.convert_error_to_porcelain(e) from e 2383 break 2384 2385 resp = models.IdentityAliasDeleteResponse() 2386 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2387 plumbing_response.meta) 2388 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2389 plumbing_response.rate_limit) 2390 return resp 2391 2392 def list(self, filter, *args, timeout=None): 2393 ''' 2394 List gets a list of IdentityAliases matching a given set of criteria. 2395 ''' 2396 deadline = None if timeout is None else time.time() + timeout 2397 req = IdentityAliasListRequest() 2398 req.meta.CopyFrom(ListRequestMetadata()) 2399 if self.parent.page_limit > 0: 2400 req.meta.limit = self.parent.page_limit 2401 if self.parent.snapshot_datetime is not None: 2402 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2403 2404 req.filter = plumbing.quote_filter_args(filter, *args) 2405 2406 def generator(svc, req): 2407 tries = 0 2408 while True: 2409 t = None if deadline is None else deadline - time.time() 2410 try: 2411 plumbing_response = svc.stub.List( 2412 req, 2413 metadata=svc.parent.get_metadata( 2414 'IdentityAliases.List', req), 2415 timeout=t) 2416 except Exception as e: 2417 if self.parent.shouldRetry(tries, e, deadline): 2418 tries += 1 2419 time.sleep( 2420 self.parent.exponentialBackoff(tries, deadline)) 2421 continue 2422 raise plumbing.convert_error_to_porcelain(e) from e 2423 tries = 0 2424 for plumbing_item in plumbing_response.identity_aliases: 2425 yield plumbing.convert_identity_alias_to_porcelain( 2426 plumbing_item) 2427 if plumbing_response.meta.next_cursor == '': 2428 break 2429 req.meta.cursor = plumbing_response.meta.next_cursor 2430 2431 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)
2247 def create(self, identity_alias, timeout=None): 2248 ''' 2249 Create registers a new IdentityAlias. 2250 ''' 2251 deadline = None if timeout is None else time.time() + timeout 2252 req = IdentityAliasCreateRequest() 2253 2254 if identity_alias is not None: 2255 req.identity_alias.CopyFrom( 2256 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2257 tries = 0 2258 plumbing_response = None 2259 while True: 2260 t = None if deadline is None else deadline - time.time() 2261 try: 2262 plumbing_response = self.stub.Create( 2263 req, 2264 metadata=self.parent.get_metadata('IdentityAliases.Create', 2265 req), 2266 timeout=t) 2267 except Exception as e: 2268 if self.parent.shouldRetry(tries, e, deadline): 2269 tries += 1 2270 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2271 continue 2272 raise plumbing.convert_error_to_porcelain(e) from e 2273 break 2274 2275 resp = models.IdentityAliasCreateResponse() 2276 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2277 plumbing_response.identity_alias) 2278 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2279 plumbing_response.meta) 2280 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2281 plumbing_response.rate_limit) 2282 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
2284 def get(self, id, timeout=None): 2285 ''' 2286 Get reads one IdentityAlias by ID. 2287 ''' 2288 deadline = None if timeout is None else time.time() + timeout 2289 req = IdentityAliasGetRequest() 2290 if self.parent.snapshot_datetime is not None: 2291 req.meta.CopyFrom(GetRequestMetadata()) 2292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2293 2294 req.id = (id) 2295 tries = 0 2296 plumbing_response = None 2297 while True: 2298 t = None if deadline is None else deadline - time.time() 2299 try: 2300 plumbing_response = self.stub.Get( 2301 req, 2302 metadata=self.parent.get_metadata('IdentityAliases.Get', 2303 req), 2304 timeout=t) 2305 except Exception as e: 2306 if self.parent.shouldRetry(tries, e, deadline): 2307 tries += 1 2308 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2309 continue 2310 raise plumbing.convert_error_to_porcelain(e) from e 2311 break 2312 2313 resp = models.IdentityAliasGetResponse() 2314 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2315 plumbing_response.identity_alias) 2316 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2317 plumbing_response.meta) 2318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2319 plumbing_response.rate_limit) 2320 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
2322 def update(self, identity_alias, timeout=None): 2323 ''' 2324 Update replaces all the fields of a IdentityAlias by ID. 2325 ''' 2326 deadline = None if timeout is None else time.time() + timeout 2327 req = IdentityAliasUpdateRequest() 2328 2329 if identity_alias is not None: 2330 req.identity_alias.CopyFrom( 2331 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.Update( 2338 req, 2339 metadata=self.parent.get_metadata('IdentityAliases.Update', 2340 req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.IdentityAliasUpdateResponse() 2351 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 2352 plumbing_response.identity_alias) 2353 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2354 plumbing_response.meta) 2355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2356 plumbing_response.rate_limit) 2357 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
2359 def delete(self, id, timeout=None): 2360 ''' 2361 Delete removes a IdentityAlias by ID. 2362 ''' 2363 deadline = None if timeout is None else time.time() + timeout 2364 req = IdentityAliasDeleteRequest() 2365 2366 req.id = (id) 2367 tries = 0 2368 plumbing_response = None 2369 while True: 2370 t = None if deadline is None else deadline - time.time() 2371 try: 2372 plumbing_response = self.stub.Delete( 2373 req, 2374 metadata=self.parent.get_metadata('IdentityAliases.Delete', 2375 req), 2376 timeout=t) 2377 except Exception as e: 2378 if self.parent.shouldRetry(tries, e, deadline): 2379 tries += 1 2380 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2381 continue 2382 raise plumbing.convert_error_to_porcelain(e) from e 2383 break 2384 2385 resp = models.IdentityAliasDeleteResponse() 2386 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2387 plumbing_response.meta) 2388 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2389 plumbing_response.rate_limit) 2390 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2392 def list(self, filter, *args, timeout=None): 2393 ''' 2394 List gets a list of IdentityAliases matching a given set of criteria. 2395 ''' 2396 deadline = None if timeout is None else time.time() + timeout 2397 req = IdentityAliasListRequest() 2398 req.meta.CopyFrom(ListRequestMetadata()) 2399 if self.parent.page_limit > 0: 2400 req.meta.limit = self.parent.page_limit 2401 if self.parent.snapshot_datetime is not None: 2402 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2403 2404 req.filter = plumbing.quote_filter_args(filter, *args) 2405 2406 def generator(svc, req): 2407 tries = 0 2408 while True: 2409 t = None if deadline is None else deadline - time.time() 2410 try: 2411 plumbing_response = svc.stub.List( 2412 req, 2413 metadata=svc.parent.get_metadata( 2414 'IdentityAliases.List', req), 2415 timeout=t) 2416 except Exception as e: 2417 if self.parent.shouldRetry(tries, e, deadline): 2418 tries += 1 2419 time.sleep( 2420 self.parent.exponentialBackoff(tries, deadline)) 2421 continue 2422 raise plumbing.convert_error_to_porcelain(e) from e 2423 tries = 0 2424 for plumbing_item in plumbing_response.identity_aliases: 2425 yield plumbing.convert_identity_alias_to_porcelain( 2426 plumbing_item) 2427 if plumbing_response.meta.next_cursor == '': 2428 break 2429 req.meta.cursor = plumbing_response.meta.next_cursor 2430 2431 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
2434class SnapshotIdentityAliases: 2435 ''' 2436 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 2437 service for historical queries. 2438 ''' 2439 def __init__(self, identity_aliases): 2440 self.identity_aliases = identity_aliases 2441 2442 def get(self, id, timeout=None): 2443 ''' 2444 Get reads one IdentityAlias by ID. 2445 ''' 2446 return self.identity_aliases.get(id, timeout=timeout) 2447 2448 def list(self, filter, *args, timeout=None): 2449 ''' 2450 List gets a list of IdentityAliases matching a given set of criteria. 2451 ''' 2452 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)
2442 def get(self, id, timeout=None): 2443 ''' 2444 Get reads one IdentityAlias by ID. 2445 ''' 2446 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
2448 def list(self, filter, *args, timeout=None): 2449 ''' 2450 List gets a list of IdentityAliases matching a given set of criteria. 2451 ''' 2452 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
2455class IdentityAliasesHistory: 2456 ''' 2457 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 2458 See `strongdm.models.IdentityAliasHistory`. 2459 ''' 2460 def __init__(self, channel, client): 2461 self.parent = client 2462 self.stub = IdentityAliasesHistoryStub(channel) 2463 2464 def list(self, filter, *args, timeout=None): 2465 ''' 2466 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2467 ''' 2468 deadline = None if timeout is None else time.time() + timeout 2469 req = IdentityAliasHistoryListRequest() 2470 req.meta.CopyFrom(ListRequestMetadata()) 2471 if self.parent.page_limit > 0: 2472 req.meta.limit = self.parent.page_limit 2473 if self.parent.snapshot_datetime is not None: 2474 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2475 2476 req.filter = plumbing.quote_filter_args(filter, *args) 2477 2478 def generator(svc, req): 2479 tries = 0 2480 while True: 2481 t = None if deadline is None else deadline - time.time() 2482 try: 2483 plumbing_response = svc.stub.List( 2484 req, 2485 metadata=svc.parent.get_metadata( 2486 'IdentityAliasesHistory.List', req), 2487 timeout=t) 2488 except Exception as e: 2489 if self.parent.shouldRetry(tries, e, deadline): 2490 tries += 1 2491 time.sleep( 2492 self.parent.exponentialBackoff(tries, deadline)) 2493 continue 2494 raise plumbing.convert_error_to_porcelain(e) from e 2495 tries = 0 2496 for plumbing_item in plumbing_response.history: 2497 yield plumbing.convert_identity_alias_history_to_porcelain( 2498 plumbing_item) 2499 if plumbing_response.meta.next_cursor == '': 2500 break 2501 req.meta.cursor = plumbing_response.meta.next_cursor 2502 2503 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)
2464 def list(self, filter, *args, timeout=None): 2465 ''' 2466 List gets a list of IdentityAliasHistory records matching a given set of criteria. 2467 ''' 2468 deadline = None if timeout is None else time.time() + timeout 2469 req = IdentityAliasHistoryListRequest() 2470 req.meta.CopyFrom(ListRequestMetadata()) 2471 if self.parent.page_limit > 0: 2472 req.meta.limit = self.parent.page_limit 2473 if self.parent.snapshot_datetime is not None: 2474 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2475 2476 req.filter = plumbing.quote_filter_args(filter, *args) 2477 2478 def generator(svc, req): 2479 tries = 0 2480 while True: 2481 t = None if deadline is None else deadline - time.time() 2482 try: 2483 plumbing_response = svc.stub.List( 2484 req, 2485 metadata=svc.parent.get_metadata( 2486 'IdentityAliasesHistory.List', req), 2487 timeout=t) 2488 except Exception as e: 2489 if self.parent.shouldRetry(tries, e, deadline): 2490 tries += 1 2491 time.sleep( 2492 self.parent.exponentialBackoff(tries, deadline)) 2493 continue 2494 raise plumbing.convert_error_to_porcelain(e) from e 2495 tries = 0 2496 for plumbing_item in plumbing_response.history: 2497 yield plumbing.convert_identity_alias_history_to_porcelain( 2498 plumbing_item) 2499 if plumbing_response.meta.next_cursor == '': 2500 break 2501 req.meta.cursor = plumbing_response.meta.next_cursor 2502 2503 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
2506class IdentitySets: 2507 ''' 2508 A IdentitySet is a named grouping of Identity Aliases for Accounts. 2509 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 2510 See `strongdm.models.IdentitySet`. 2511 ''' 2512 def __init__(self, channel, client): 2513 self.parent = client 2514 self.stub = IdentitySetsStub(channel) 2515 2516 def create(self, identity_set, timeout=None): 2517 ''' 2518 Create registers a new IdentitySet. 2519 ''' 2520 deadline = None if timeout is None else time.time() + timeout 2521 req = IdentitySetCreateRequest() 2522 2523 if identity_set is not None: 2524 req.identity_set.CopyFrom( 2525 plumbing.convert_identity_set_to_plumbing(identity_set)) 2526 tries = 0 2527 plumbing_response = None 2528 while True: 2529 t = None if deadline is None else deadline - time.time() 2530 try: 2531 plumbing_response = self.stub.Create( 2532 req, 2533 metadata=self.parent.get_metadata('IdentitySets.Create', 2534 req), 2535 timeout=t) 2536 except Exception as e: 2537 if self.parent.shouldRetry(tries, e, deadline): 2538 tries += 1 2539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2540 continue 2541 raise plumbing.convert_error_to_porcelain(e) from e 2542 break 2543 2544 resp = models.IdentitySetCreateResponse() 2545 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2546 plumbing_response.identity_set) 2547 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2548 plumbing_response.meta) 2549 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2550 plumbing_response.rate_limit) 2551 return resp 2552 2553 def get(self, id, timeout=None): 2554 ''' 2555 Get reads one IdentitySet by ID. 2556 ''' 2557 deadline = None if timeout is None else time.time() + timeout 2558 req = IdentitySetGetRequest() 2559 if self.parent.snapshot_datetime is not None: 2560 req.meta.CopyFrom(GetRequestMetadata()) 2561 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2562 2563 req.id = (id) 2564 tries = 0 2565 plumbing_response = None 2566 while True: 2567 t = None if deadline is None else deadline - time.time() 2568 try: 2569 plumbing_response = self.stub.Get( 2570 req, 2571 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2572 timeout=t) 2573 except Exception as e: 2574 if self.parent.shouldRetry(tries, e, deadline): 2575 tries += 1 2576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2577 continue 2578 raise plumbing.convert_error_to_porcelain(e) from e 2579 break 2580 2581 resp = models.IdentitySetGetResponse() 2582 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2583 plumbing_response.identity_set) 2584 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2585 plumbing_response.meta) 2586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2587 plumbing_response.rate_limit) 2588 return resp 2589 2590 def update(self, identity_set, timeout=None): 2591 ''' 2592 Update replaces all the fields of a IdentitySet by ID. 2593 ''' 2594 deadline = None if timeout is None else time.time() + timeout 2595 req = IdentitySetUpdateRequest() 2596 2597 if identity_set is not None: 2598 req.identity_set.CopyFrom( 2599 plumbing.convert_identity_set_to_plumbing(identity_set)) 2600 tries = 0 2601 plumbing_response = None 2602 while True: 2603 t = None if deadline is None else deadline - time.time() 2604 try: 2605 plumbing_response = self.stub.Update( 2606 req, 2607 metadata=self.parent.get_metadata('IdentitySets.Update', 2608 req), 2609 timeout=t) 2610 except Exception as e: 2611 if self.parent.shouldRetry(tries, e, deadline): 2612 tries += 1 2613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2614 continue 2615 raise plumbing.convert_error_to_porcelain(e) from e 2616 break 2617 2618 resp = models.IdentitySetUpdateResponse() 2619 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2620 plumbing_response.identity_set) 2621 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2622 plumbing_response.meta) 2623 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2624 plumbing_response.rate_limit) 2625 return resp 2626 2627 def delete(self, id, timeout=None): 2628 ''' 2629 Delete removes a IdentitySet by ID. 2630 ''' 2631 deadline = None if timeout is None else time.time() + timeout 2632 req = IdentitySetDeleteRequest() 2633 2634 req.id = (id) 2635 tries = 0 2636 plumbing_response = None 2637 while True: 2638 t = None if deadline is None else deadline - time.time() 2639 try: 2640 plumbing_response = self.stub.Delete( 2641 req, 2642 metadata=self.parent.get_metadata('IdentitySets.Delete', 2643 req), 2644 timeout=t) 2645 except Exception as e: 2646 if self.parent.shouldRetry(tries, e, deadline): 2647 tries += 1 2648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2649 continue 2650 raise plumbing.convert_error_to_porcelain(e) from e 2651 break 2652 2653 resp = models.IdentitySetDeleteResponse() 2654 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2655 plumbing_response.meta) 2656 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2657 plumbing_response.rate_limit) 2658 return resp 2659 2660 def list(self, filter, *args, timeout=None): 2661 ''' 2662 List gets a list of IdentitySets matching a given set of criteria. 2663 ''' 2664 deadline = None if timeout is None else time.time() + timeout 2665 req = IdentitySetListRequest() 2666 req.meta.CopyFrom(ListRequestMetadata()) 2667 if self.parent.page_limit > 0: 2668 req.meta.limit = self.parent.page_limit 2669 if self.parent.snapshot_datetime is not None: 2670 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2671 2672 req.filter = plumbing.quote_filter_args(filter, *args) 2673 2674 def generator(svc, req): 2675 tries = 0 2676 while True: 2677 t = None if deadline is None else deadline - time.time() 2678 try: 2679 plumbing_response = svc.stub.List( 2680 req, 2681 metadata=svc.parent.get_metadata( 2682 'IdentitySets.List', req), 2683 timeout=t) 2684 except Exception as e: 2685 if self.parent.shouldRetry(tries, e, deadline): 2686 tries += 1 2687 time.sleep( 2688 self.parent.exponentialBackoff(tries, deadline)) 2689 continue 2690 raise plumbing.convert_error_to_porcelain(e) from e 2691 tries = 0 2692 for plumbing_item in plumbing_response.identity_sets: 2693 yield plumbing.convert_identity_set_to_porcelain( 2694 plumbing_item) 2695 if plumbing_response.meta.next_cursor == '': 2696 break 2697 req.meta.cursor = plumbing_response.meta.next_cursor 2698 2699 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)
2516 def create(self, identity_set, timeout=None): 2517 ''' 2518 Create registers a new IdentitySet. 2519 ''' 2520 deadline = None if timeout is None else time.time() + timeout 2521 req = IdentitySetCreateRequest() 2522 2523 if identity_set is not None: 2524 req.identity_set.CopyFrom( 2525 plumbing.convert_identity_set_to_plumbing(identity_set)) 2526 tries = 0 2527 plumbing_response = None 2528 while True: 2529 t = None if deadline is None else deadline - time.time() 2530 try: 2531 plumbing_response = self.stub.Create( 2532 req, 2533 metadata=self.parent.get_metadata('IdentitySets.Create', 2534 req), 2535 timeout=t) 2536 except Exception as e: 2537 if self.parent.shouldRetry(tries, e, deadline): 2538 tries += 1 2539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2540 continue 2541 raise plumbing.convert_error_to_porcelain(e) from e 2542 break 2543 2544 resp = models.IdentitySetCreateResponse() 2545 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2546 plumbing_response.identity_set) 2547 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2548 plumbing_response.meta) 2549 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2550 plumbing_response.rate_limit) 2551 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
2553 def get(self, id, timeout=None): 2554 ''' 2555 Get reads one IdentitySet by ID. 2556 ''' 2557 deadline = None if timeout is None else time.time() + timeout 2558 req = IdentitySetGetRequest() 2559 if self.parent.snapshot_datetime is not None: 2560 req.meta.CopyFrom(GetRequestMetadata()) 2561 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2562 2563 req.id = (id) 2564 tries = 0 2565 plumbing_response = None 2566 while True: 2567 t = None if deadline is None else deadline - time.time() 2568 try: 2569 plumbing_response = self.stub.Get( 2570 req, 2571 metadata=self.parent.get_metadata('IdentitySets.Get', req), 2572 timeout=t) 2573 except Exception as e: 2574 if self.parent.shouldRetry(tries, e, deadline): 2575 tries += 1 2576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2577 continue 2578 raise plumbing.convert_error_to_porcelain(e) from e 2579 break 2580 2581 resp = models.IdentitySetGetResponse() 2582 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2583 plumbing_response.identity_set) 2584 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2585 plumbing_response.meta) 2586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2587 plumbing_response.rate_limit) 2588 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
2590 def update(self, identity_set, timeout=None): 2591 ''' 2592 Update replaces all the fields of a IdentitySet by ID. 2593 ''' 2594 deadline = None if timeout is None else time.time() + timeout 2595 req = IdentitySetUpdateRequest() 2596 2597 if identity_set is not None: 2598 req.identity_set.CopyFrom( 2599 plumbing.convert_identity_set_to_plumbing(identity_set)) 2600 tries = 0 2601 plumbing_response = None 2602 while True: 2603 t = None if deadline is None else deadline - time.time() 2604 try: 2605 plumbing_response = self.stub.Update( 2606 req, 2607 metadata=self.parent.get_metadata('IdentitySets.Update', 2608 req), 2609 timeout=t) 2610 except Exception as e: 2611 if self.parent.shouldRetry(tries, e, deadline): 2612 tries += 1 2613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2614 continue 2615 raise plumbing.convert_error_to_porcelain(e) from e 2616 break 2617 2618 resp = models.IdentitySetUpdateResponse() 2619 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 2620 plumbing_response.identity_set) 2621 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2622 plumbing_response.meta) 2623 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2624 plumbing_response.rate_limit) 2625 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
2627 def delete(self, id, timeout=None): 2628 ''' 2629 Delete removes a IdentitySet by ID. 2630 ''' 2631 deadline = None if timeout is None else time.time() + timeout 2632 req = IdentitySetDeleteRequest() 2633 2634 req.id = (id) 2635 tries = 0 2636 plumbing_response = None 2637 while True: 2638 t = None if deadline is None else deadline - time.time() 2639 try: 2640 plumbing_response = self.stub.Delete( 2641 req, 2642 metadata=self.parent.get_metadata('IdentitySets.Delete', 2643 req), 2644 timeout=t) 2645 except Exception as e: 2646 if self.parent.shouldRetry(tries, e, deadline): 2647 tries += 1 2648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2649 continue 2650 raise plumbing.convert_error_to_porcelain(e) from e 2651 break 2652 2653 resp = models.IdentitySetDeleteResponse() 2654 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2655 plumbing_response.meta) 2656 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2657 plumbing_response.rate_limit) 2658 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2660 def list(self, filter, *args, timeout=None): 2661 ''' 2662 List gets a list of IdentitySets matching a given set of criteria. 2663 ''' 2664 deadline = None if timeout is None else time.time() + timeout 2665 req = IdentitySetListRequest() 2666 req.meta.CopyFrom(ListRequestMetadata()) 2667 if self.parent.page_limit > 0: 2668 req.meta.limit = self.parent.page_limit 2669 if self.parent.snapshot_datetime is not None: 2670 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2671 2672 req.filter = plumbing.quote_filter_args(filter, *args) 2673 2674 def generator(svc, req): 2675 tries = 0 2676 while True: 2677 t = None if deadline is None else deadline - time.time() 2678 try: 2679 plumbing_response = svc.stub.List( 2680 req, 2681 metadata=svc.parent.get_metadata( 2682 'IdentitySets.List', req), 2683 timeout=t) 2684 except Exception as e: 2685 if self.parent.shouldRetry(tries, e, deadline): 2686 tries += 1 2687 time.sleep( 2688 self.parent.exponentialBackoff(tries, deadline)) 2689 continue 2690 raise plumbing.convert_error_to_porcelain(e) from e 2691 tries = 0 2692 for plumbing_item in plumbing_response.identity_sets: 2693 yield plumbing.convert_identity_set_to_porcelain( 2694 plumbing_item) 2695 if plumbing_response.meta.next_cursor == '': 2696 break 2697 req.meta.cursor = plumbing_response.meta.next_cursor 2698 2699 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
2702class SnapshotIdentitySets: 2703 ''' 2704 SnapshotIdentitySets exposes the read only methods of the IdentitySets 2705 service for historical queries. 2706 ''' 2707 def __init__(self, identity_sets): 2708 self.identity_sets = identity_sets 2709 2710 def get(self, id, timeout=None): 2711 ''' 2712 Get reads one IdentitySet by ID. 2713 ''' 2714 return self.identity_sets.get(id, timeout=timeout) 2715 2716 def list(self, filter, *args, timeout=None): 2717 ''' 2718 List gets a list of IdentitySets matching a given set of criteria. 2719 ''' 2720 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)
2710 def get(self, id, timeout=None): 2711 ''' 2712 Get reads one IdentitySet by ID. 2713 ''' 2714 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
2716 def list(self, filter, *args, timeout=None): 2717 ''' 2718 List gets a list of IdentitySets matching a given set of criteria. 2719 ''' 2720 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
2723class IdentitySetsHistory: 2724 ''' 2725 IdentitySetsHistory records all changes to the state of a IdentitySet. 2726 See `strongdm.models.IdentitySetHistory`. 2727 ''' 2728 def __init__(self, channel, client): 2729 self.parent = client 2730 self.stub = IdentitySetsHistoryStub(channel) 2731 2732 def list(self, filter, *args, timeout=None): 2733 ''' 2734 List gets a list of IdentitySetHistory records matching a given set of criteria. 2735 ''' 2736 deadline = None if timeout is None else time.time() + timeout 2737 req = IdentitySetHistoryListRequest() 2738 req.meta.CopyFrom(ListRequestMetadata()) 2739 if self.parent.page_limit > 0: 2740 req.meta.limit = self.parent.page_limit 2741 if self.parent.snapshot_datetime is not None: 2742 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2743 2744 req.filter = plumbing.quote_filter_args(filter, *args) 2745 2746 def generator(svc, req): 2747 tries = 0 2748 while True: 2749 t = None if deadline is None else deadline - time.time() 2750 try: 2751 plumbing_response = svc.stub.List( 2752 req, 2753 metadata=svc.parent.get_metadata( 2754 'IdentitySetsHistory.List', req), 2755 timeout=t) 2756 except Exception as e: 2757 if self.parent.shouldRetry(tries, e, deadline): 2758 tries += 1 2759 time.sleep( 2760 self.parent.exponentialBackoff(tries, deadline)) 2761 continue 2762 raise plumbing.convert_error_to_porcelain(e) from e 2763 tries = 0 2764 for plumbing_item in plumbing_response.history: 2765 yield plumbing.convert_identity_set_history_to_porcelain( 2766 plumbing_item) 2767 if plumbing_response.meta.next_cursor == '': 2768 break 2769 req.meta.cursor = plumbing_response.meta.next_cursor 2770 2771 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)
2732 def list(self, filter, *args, timeout=None): 2733 ''' 2734 List gets a list of IdentitySetHistory records matching a given set of criteria. 2735 ''' 2736 deadline = None if timeout is None else time.time() + timeout 2737 req = IdentitySetHistoryListRequest() 2738 req.meta.CopyFrom(ListRequestMetadata()) 2739 if self.parent.page_limit > 0: 2740 req.meta.limit = self.parent.page_limit 2741 if self.parent.snapshot_datetime is not None: 2742 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2743 2744 req.filter = plumbing.quote_filter_args(filter, *args) 2745 2746 def generator(svc, req): 2747 tries = 0 2748 while True: 2749 t = None if deadline is None else deadline - time.time() 2750 try: 2751 plumbing_response = svc.stub.List( 2752 req, 2753 metadata=svc.parent.get_metadata( 2754 'IdentitySetsHistory.List', req), 2755 timeout=t) 2756 except Exception as e: 2757 if self.parent.shouldRetry(tries, e, deadline): 2758 tries += 1 2759 time.sleep( 2760 self.parent.exponentialBackoff(tries, deadline)) 2761 continue 2762 raise plumbing.convert_error_to_porcelain(e) from e 2763 tries = 0 2764 for plumbing_item in plumbing_response.history: 2765 yield plumbing.convert_identity_set_history_to_porcelain( 2766 plumbing_item) 2767 if plumbing_response.meta.next_cursor == '': 2768 break 2769 req.meta.cursor = plumbing_response.meta.next_cursor 2770 2771 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
2774class ManagedSecrets: 2775 ''' 2776 ManagedSecret is a private vertical for creating, reading, updating, 2777 deleting, listing and rotating the managed secrets in the secrets engines as 2778 an authenticated user. 2779 See `strongdm.models.ManagedSecret`. 2780 ''' 2781 def __init__(self, channel, client): 2782 self.parent = client 2783 self.stub = ManagedSecretsStub(channel) 2784 2785 def list(self, filter, *args, timeout=None): 2786 ''' 2787 List returns Managed Secrets from a Secret Engine. 2788 ''' 2789 deadline = None if timeout is None else time.time() + timeout 2790 req = ManagedSecretListRequest() 2791 req.meta.CopyFrom(ListRequestMetadata()) 2792 if self.parent.page_limit > 0: 2793 req.meta.limit = self.parent.page_limit 2794 if self.parent.snapshot_datetime is not None: 2795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2796 2797 req.filter = plumbing.quote_filter_args(filter, *args) 2798 2799 def generator(svc, req): 2800 tries = 0 2801 while True: 2802 t = None if deadline is None else deadline - time.time() 2803 try: 2804 plumbing_response = svc.stub.List( 2805 req, 2806 metadata=svc.parent.get_metadata( 2807 'ManagedSecrets.List', req), 2808 timeout=t) 2809 except Exception as e: 2810 if self.parent.shouldRetry(tries, e, deadline): 2811 tries += 1 2812 time.sleep( 2813 self.parent.exponentialBackoff(tries, deadline)) 2814 continue 2815 raise plumbing.convert_error_to_porcelain(e) from e 2816 tries = 0 2817 for plumbing_item in plumbing_response.managed_secrets: 2818 yield plumbing.convert_managed_secret_to_porcelain( 2819 plumbing_item) 2820 if plumbing_response.meta.next_cursor == '': 2821 break 2822 req.meta.cursor = plumbing_response.meta.next_cursor 2823 2824 return generator(self, req) 2825 2826 def list_by_actor(self, filter, *args, timeout=None): 2827 ''' 2828 List returns Managed Secrets for an Actor from a Secret Engine. 2829 ''' 2830 deadline = None if timeout is None else time.time() + timeout 2831 req = ManagedSecretListRequest() 2832 req.meta.CopyFrom(ListRequestMetadata()) 2833 if self.parent.page_limit > 0: 2834 req.meta.limit = self.parent.page_limit 2835 if self.parent.snapshot_datetime is not None: 2836 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2837 2838 req.filter = plumbing.quote_filter_args(filter, *args) 2839 2840 def generator(svc, req): 2841 tries = 0 2842 while True: 2843 t = None if deadline is None else deadline - time.time() 2844 try: 2845 plumbing_response = svc.stub.ListByActor( 2846 req, 2847 metadata=svc.parent.get_metadata( 2848 'ManagedSecrets.ListByActor', req), 2849 timeout=t) 2850 except Exception as e: 2851 if self.parent.shouldRetry(tries, e, deadline): 2852 tries += 1 2853 time.sleep( 2854 self.parent.exponentialBackoff(tries, deadline)) 2855 continue 2856 raise plumbing.convert_error_to_porcelain(e) from e 2857 tries = 0 2858 for plumbing_item in plumbing_response.managed_secrets: 2859 yield plumbing.convert_managed_secret_to_porcelain( 2860 plumbing_item) 2861 if plumbing_response.meta.next_cursor == '': 2862 break 2863 req.meta.cursor = plumbing_response.meta.next_cursor 2864 2865 return generator(self, req) 2866 2867 def create(self, managed_secret, timeout=None): 2868 ''' 2869 Create creates a Managed Secret 2870 ''' 2871 deadline = None if timeout is None else time.time() + timeout 2872 req = ManagedSecretCreateRequest() 2873 2874 if managed_secret is not None: 2875 req.managed_secret.CopyFrom( 2876 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2877 tries = 0 2878 plumbing_response = None 2879 while True: 2880 t = None if deadline is None else deadline - time.time() 2881 try: 2882 plumbing_response = self.stub.Create( 2883 req, 2884 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2885 req), 2886 timeout=t) 2887 except Exception as e: 2888 if self.parent.shouldRetry(tries, e, deadline): 2889 tries += 1 2890 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2891 continue 2892 raise plumbing.convert_error_to_porcelain(e) from e 2893 break 2894 2895 resp = models.ManagedSecretCreateResponse() 2896 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2897 plumbing_response.managed_secret) 2898 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2899 plumbing_response.meta) 2900 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2901 plumbing_response.rate_limit) 2902 return resp 2903 2904 def update(self, managed_secret, timeout=None): 2905 ''' 2906 Update updates a Managed Secret 2907 ''' 2908 deadline = None if timeout is None else time.time() + timeout 2909 req = ManagedSecretUpdateRequest() 2910 2911 if managed_secret is not None: 2912 req.managed_secret.CopyFrom( 2913 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2914 tries = 0 2915 plumbing_response = None 2916 while True: 2917 t = None if deadline is None else deadline - time.time() 2918 try: 2919 plumbing_response = self.stub.Update( 2920 req, 2921 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2922 req), 2923 timeout=t) 2924 except Exception as e: 2925 if self.parent.shouldRetry(tries, e, deadline): 2926 tries += 1 2927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2928 continue 2929 raise plumbing.convert_error_to_porcelain(e) from e 2930 break 2931 2932 resp = models.ManagedSecretUpdateResponse() 2933 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2934 plumbing_response.managed_secret) 2935 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2936 plumbing_response.meta) 2937 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2938 plumbing_response.rate_limit) 2939 return resp 2940 2941 def rotate(self, id, timeout=None): 2942 ''' 2943 Rotate forces rotation of Managed Secret 2944 ''' 2945 deadline = None if timeout is None else time.time() + timeout 2946 req = ManagedSecretRotateRequest() 2947 2948 req.id = (id) 2949 tries = 0 2950 plumbing_response = None 2951 while True: 2952 t = None if deadline is None else deadline - time.time() 2953 try: 2954 plumbing_response = self.stub.Rotate( 2955 req, 2956 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2957 req), 2958 timeout=t) 2959 except Exception as e: 2960 if self.parent.shouldRetry(tries, e, deadline): 2961 tries += 1 2962 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2963 continue 2964 raise plumbing.convert_error_to_porcelain(e) from e 2965 break 2966 2967 resp = models.ManagedSecretRotateResponse() 2968 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2969 plumbing_response.meta) 2970 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2971 plumbing_response.rate_limit) 2972 return resp 2973 2974 def delete(self, id, timeout=None): 2975 ''' 2976 Delete deletes a Managed Secret 2977 ''' 2978 deadline = None if timeout is None else time.time() + timeout 2979 req = ManagedSecretDeleteRequest() 2980 2981 req.id = (id) 2982 tries = 0 2983 plumbing_response = None 2984 while True: 2985 t = None if deadline is None else deadline - time.time() 2986 try: 2987 plumbing_response = self.stub.Delete( 2988 req, 2989 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2990 req), 2991 timeout=t) 2992 except Exception as e: 2993 if self.parent.shouldRetry(tries, e, deadline): 2994 tries += 1 2995 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2996 continue 2997 raise plumbing.convert_error_to_porcelain(e) from e 2998 break 2999 3000 resp = models.ManagedSecretDeleteResponse() 3001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3002 plumbing_response.rate_limit) 3003 return resp 3004 3005 def get(self, id, timeout=None): 3006 ''' 3007 Get gets details of a Managed Secret without sensitive data 3008 ''' 3009 deadline = None if timeout is None else time.time() + timeout 3010 req = ManagedSecretGetRequest() 3011 if self.parent.snapshot_datetime is not None: 3012 req.meta.CopyFrom(GetRequestMetadata()) 3013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3014 3015 req.id = (id) 3016 tries = 0 3017 plumbing_response = None 3018 while True: 3019 t = None if deadline is None else deadline - time.time() 3020 try: 3021 plumbing_response = self.stub.Get( 3022 req, 3023 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3024 req), 3025 timeout=t) 3026 except Exception as e: 3027 if self.parent.shouldRetry(tries, e, deadline): 3028 tries += 1 3029 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3030 continue 3031 raise plumbing.convert_error_to_porcelain(e) from e 3032 break 3033 3034 resp = models.ManagedSecretGetResponse() 3035 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3036 plumbing_response.managed_secret) 3037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3038 plumbing_response.meta) 3039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3040 plumbing_response.rate_limit) 3041 return resp 3042 3043 def retrieve(self, id, public_key, timeout=None): 3044 ''' 3045 Retrieve returns Managed Secret with sensitive data 3046 ''' 3047 deadline = None if timeout is None else time.time() + timeout 3048 req = ManagedSecretRetrieveRequest() 3049 3050 req.id = (id) 3051 req.public_key = (public_key) 3052 tries = 0 3053 plumbing_response = None 3054 while True: 3055 t = None if deadline is None else deadline - time.time() 3056 try: 3057 plumbing_response = self.stub.Retrieve( 3058 req, 3059 metadata=self.parent.get_metadata( 3060 'ManagedSecrets.Retrieve', req), 3061 timeout=t) 3062 except Exception as e: 3063 if self.parent.shouldRetry(tries, e, deadline): 3064 tries += 1 3065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 break 3069 3070 resp = models.ManagedSecretRetrieveResponse() 3071 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3072 plumbing_response.managed_secret) 3073 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3074 plumbing_response.meta) 3075 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3076 plumbing_response.rate_limit) 3077 return resp 3078 3079 def validate(self, id, timeout=None): 3080 ''' 3081 Validate returns the result of testing the stored credential against the 3082 secret engine. 3083 ''' 3084 deadline = None if timeout is None else time.time() + timeout 3085 req = ManagedSecretValidateRequest() 3086 3087 req.id = (id) 3088 tries = 0 3089 plumbing_response = None 3090 while True: 3091 t = None if deadline is None else deadline - time.time() 3092 try: 3093 plumbing_response = self.stub.Validate( 3094 req, 3095 metadata=self.parent.get_metadata( 3096 'ManagedSecrets.Validate', req), 3097 timeout=t) 3098 except Exception as e: 3099 if self.parent.shouldRetry(tries, e, deadline): 3100 tries += 1 3101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3102 continue 3103 raise plumbing.convert_error_to_porcelain(e) from e 3104 break 3105 3106 resp = models.ManagedSecretValidateResponse() 3107 resp.invalid_info = (plumbing_response.invalid_info) 3108 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3109 plumbing_response.meta) 3110 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3111 plumbing_response.rate_limit) 3112 resp.valid = (plumbing_response.valid) 3113 return resp 3114 3115 def logs(self, filter, *args, timeout=None): 3116 ''' 3117 Logs returns the audit records for the managed secret. This may be replaced 3118 in the future. 3119 ''' 3120 deadline = None if timeout is None else time.time() + timeout 3121 req = ManagedSecretLogsRequest() 3122 req.meta.CopyFrom(ListRequestMetadata()) 3123 if self.parent.page_limit > 0: 3124 req.meta.limit = self.parent.page_limit 3125 if self.parent.snapshot_datetime is not None: 3126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3127 3128 req.filter = plumbing.quote_filter_args(filter, *args) 3129 3130 def generator(svc, req): 3131 tries = 0 3132 while True: 3133 t = None if deadline is None else deadline - time.time() 3134 try: 3135 plumbing_response = svc.stub.Logs( 3136 req, 3137 metadata=svc.parent.get_metadata( 3138 'ManagedSecrets.Logs', req), 3139 timeout=t) 3140 except Exception as e: 3141 if self.parent.shouldRetry(tries, e, deadline): 3142 tries += 1 3143 time.sleep( 3144 self.parent.exponentialBackoff(tries, deadline)) 3145 continue 3146 raise plumbing.convert_error_to_porcelain(e) from e 3147 tries = 0 3148 for plumbing_item in plumbing_response.managed_secret_logs: 3149 yield plumbing.convert_managed_secret_log_to_porcelain( 3150 plumbing_item) 3151 if plumbing_response.meta.next_cursor == '': 3152 break 3153 req.meta.cursor = plumbing_response.meta.next_cursor 3154 3155 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)
2785 def list(self, filter, *args, timeout=None): 2786 ''' 2787 List returns Managed Secrets from a Secret Engine. 2788 ''' 2789 deadline = None if timeout is None else time.time() + timeout 2790 req = ManagedSecretListRequest() 2791 req.meta.CopyFrom(ListRequestMetadata()) 2792 if self.parent.page_limit > 0: 2793 req.meta.limit = self.parent.page_limit 2794 if self.parent.snapshot_datetime is not None: 2795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2796 2797 req.filter = plumbing.quote_filter_args(filter, *args) 2798 2799 def generator(svc, req): 2800 tries = 0 2801 while True: 2802 t = None if deadline is None else deadline - time.time() 2803 try: 2804 plumbing_response = svc.stub.List( 2805 req, 2806 metadata=svc.parent.get_metadata( 2807 'ManagedSecrets.List', req), 2808 timeout=t) 2809 except Exception as e: 2810 if self.parent.shouldRetry(tries, e, deadline): 2811 tries += 1 2812 time.sleep( 2813 self.parent.exponentialBackoff(tries, deadline)) 2814 continue 2815 raise plumbing.convert_error_to_porcelain(e) from e 2816 tries = 0 2817 for plumbing_item in plumbing_response.managed_secrets: 2818 yield plumbing.convert_managed_secret_to_porcelain( 2819 plumbing_item) 2820 if plumbing_response.meta.next_cursor == '': 2821 break 2822 req.meta.cursor = plumbing_response.meta.next_cursor 2823 2824 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
2826 def list_by_actor(self, filter, *args, timeout=None): 2827 ''' 2828 List returns Managed Secrets for an Actor from a Secret Engine. 2829 ''' 2830 deadline = None if timeout is None else time.time() + timeout 2831 req = ManagedSecretListRequest() 2832 req.meta.CopyFrom(ListRequestMetadata()) 2833 if self.parent.page_limit > 0: 2834 req.meta.limit = self.parent.page_limit 2835 if self.parent.snapshot_datetime is not None: 2836 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2837 2838 req.filter = plumbing.quote_filter_args(filter, *args) 2839 2840 def generator(svc, req): 2841 tries = 0 2842 while True: 2843 t = None if deadline is None else deadline - time.time() 2844 try: 2845 plumbing_response = svc.stub.ListByActor( 2846 req, 2847 metadata=svc.parent.get_metadata( 2848 'ManagedSecrets.ListByActor', req), 2849 timeout=t) 2850 except Exception as e: 2851 if self.parent.shouldRetry(tries, e, deadline): 2852 tries += 1 2853 time.sleep( 2854 self.parent.exponentialBackoff(tries, deadline)) 2855 continue 2856 raise plumbing.convert_error_to_porcelain(e) from e 2857 tries = 0 2858 for plumbing_item in plumbing_response.managed_secrets: 2859 yield plumbing.convert_managed_secret_to_porcelain( 2860 plumbing_item) 2861 if plumbing_response.meta.next_cursor == '': 2862 break 2863 req.meta.cursor = plumbing_response.meta.next_cursor 2864 2865 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
2867 def create(self, managed_secret, timeout=None): 2868 ''' 2869 Create creates a Managed Secret 2870 ''' 2871 deadline = None if timeout is None else time.time() + timeout 2872 req = ManagedSecretCreateRequest() 2873 2874 if managed_secret is not None: 2875 req.managed_secret.CopyFrom( 2876 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2877 tries = 0 2878 plumbing_response = None 2879 while True: 2880 t = None if deadline is None else deadline - time.time() 2881 try: 2882 plumbing_response = self.stub.Create( 2883 req, 2884 metadata=self.parent.get_metadata('ManagedSecrets.Create', 2885 req), 2886 timeout=t) 2887 except Exception as e: 2888 if self.parent.shouldRetry(tries, e, deadline): 2889 tries += 1 2890 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2891 continue 2892 raise plumbing.convert_error_to_porcelain(e) from e 2893 break 2894 2895 resp = models.ManagedSecretCreateResponse() 2896 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2897 plumbing_response.managed_secret) 2898 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2899 plumbing_response.meta) 2900 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2901 plumbing_response.rate_limit) 2902 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
2904 def update(self, managed_secret, timeout=None): 2905 ''' 2906 Update updates a Managed Secret 2907 ''' 2908 deadline = None if timeout is None else time.time() + timeout 2909 req = ManagedSecretUpdateRequest() 2910 2911 if managed_secret is not None: 2912 req.managed_secret.CopyFrom( 2913 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 2914 tries = 0 2915 plumbing_response = None 2916 while True: 2917 t = None if deadline is None else deadline - time.time() 2918 try: 2919 plumbing_response = self.stub.Update( 2920 req, 2921 metadata=self.parent.get_metadata('ManagedSecrets.Update', 2922 req), 2923 timeout=t) 2924 except Exception as e: 2925 if self.parent.shouldRetry(tries, e, deadline): 2926 tries += 1 2927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2928 continue 2929 raise plumbing.convert_error_to_porcelain(e) from e 2930 break 2931 2932 resp = models.ManagedSecretUpdateResponse() 2933 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 2934 plumbing_response.managed_secret) 2935 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2936 plumbing_response.meta) 2937 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2938 plumbing_response.rate_limit) 2939 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
2941 def rotate(self, id, timeout=None): 2942 ''' 2943 Rotate forces rotation of Managed Secret 2944 ''' 2945 deadline = None if timeout is None else time.time() + timeout 2946 req = ManagedSecretRotateRequest() 2947 2948 req.id = (id) 2949 tries = 0 2950 plumbing_response = None 2951 while True: 2952 t = None if deadline is None else deadline - time.time() 2953 try: 2954 plumbing_response = self.stub.Rotate( 2955 req, 2956 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 2957 req), 2958 timeout=t) 2959 except Exception as e: 2960 if self.parent.shouldRetry(tries, e, deadline): 2961 tries += 1 2962 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2963 continue 2964 raise plumbing.convert_error_to_porcelain(e) from e 2965 break 2966 2967 resp = models.ManagedSecretRotateResponse() 2968 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 2969 plumbing_response.meta) 2970 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2971 plumbing_response.rate_limit) 2972 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
2974 def delete(self, id, timeout=None): 2975 ''' 2976 Delete deletes a Managed Secret 2977 ''' 2978 deadline = None if timeout is None else time.time() + timeout 2979 req = ManagedSecretDeleteRequest() 2980 2981 req.id = (id) 2982 tries = 0 2983 plumbing_response = None 2984 while True: 2985 t = None if deadline is None else deadline - time.time() 2986 try: 2987 plumbing_response = self.stub.Delete( 2988 req, 2989 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 2990 req), 2991 timeout=t) 2992 except Exception as e: 2993 if self.parent.shouldRetry(tries, e, deadline): 2994 tries += 1 2995 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2996 continue 2997 raise plumbing.convert_error_to_porcelain(e) from e 2998 break 2999 3000 resp = models.ManagedSecretDeleteResponse() 3001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3002 plumbing_response.rate_limit) 3003 return resp
Delete deletes a Managed Secret
def
get(self, id, timeout=None)
3005 def get(self, id, timeout=None): 3006 ''' 3007 Get gets details of a Managed Secret without sensitive data 3008 ''' 3009 deadline = None if timeout is None else time.time() + timeout 3010 req = ManagedSecretGetRequest() 3011 if self.parent.snapshot_datetime is not None: 3012 req.meta.CopyFrom(GetRequestMetadata()) 3013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3014 3015 req.id = (id) 3016 tries = 0 3017 plumbing_response = None 3018 while True: 3019 t = None if deadline is None else deadline - time.time() 3020 try: 3021 plumbing_response = self.stub.Get( 3022 req, 3023 metadata=self.parent.get_metadata('ManagedSecrets.Get', 3024 req), 3025 timeout=t) 3026 except Exception as e: 3027 if self.parent.shouldRetry(tries, e, deadline): 3028 tries += 1 3029 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3030 continue 3031 raise plumbing.convert_error_to_porcelain(e) from e 3032 break 3033 3034 resp = models.ManagedSecretGetResponse() 3035 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3036 plumbing_response.managed_secret) 3037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3038 plumbing_response.meta) 3039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3040 plumbing_response.rate_limit) 3041 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, public_key, timeout=None)
3043 def retrieve(self, id, public_key, timeout=None): 3044 ''' 3045 Retrieve returns Managed Secret with sensitive data 3046 ''' 3047 deadline = None if timeout is None else time.time() + timeout 3048 req = ManagedSecretRetrieveRequest() 3049 3050 req.id = (id) 3051 req.public_key = (public_key) 3052 tries = 0 3053 plumbing_response = None 3054 while True: 3055 t = None if deadline is None else deadline - time.time() 3056 try: 3057 plumbing_response = self.stub.Retrieve( 3058 req, 3059 metadata=self.parent.get_metadata( 3060 'ManagedSecrets.Retrieve', req), 3061 timeout=t) 3062 except Exception as e: 3063 if self.parent.shouldRetry(tries, e, deadline): 3064 tries += 1 3065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 break 3069 3070 resp = models.ManagedSecretRetrieveResponse() 3071 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3072 plumbing_response.managed_secret) 3073 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3074 plumbing_response.meta) 3075 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3076 plumbing_response.rate_limit) 3077 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
3079 def validate(self, id, timeout=None): 3080 ''' 3081 Validate returns the result of testing the stored credential against the 3082 secret engine. 3083 ''' 3084 deadline = None if timeout is None else time.time() + timeout 3085 req = ManagedSecretValidateRequest() 3086 3087 req.id = (id) 3088 tries = 0 3089 plumbing_response = None 3090 while True: 3091 t = None if deadline is None else deadline - time.time() 3092 try: 3093 plumbing_response = self.stub.Validate( 3094 req, 3095 metadata=self.parent.get_metadata( 3096 'ManagedSecrets.Validate', req), 3097 timeout=t) 3098 except Exception as e: 3099 if self.parent.shouldRetry(tries, e, deadline): 3100 tries += 1 3101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3102 continue 3103 raise plumbing.convert_error_to_porcelain(e) from e 3104 break 3105 3106 resp = models.ManagedSecretValidateResponse() 3107 resp.invalid_info = (plumbing_response.invalid_info) 3108 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3109 plumbing_response.meta) 3110 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3111 plumbing_response.rate_limit) 3112 resp.valid = (plumbing_response.valid) 3113 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
3115 def logs(self, filter, *args, timeout=None): 3116 ''' 3117 Logs returns the audit records for the managed secret. This may be replaced 3118 in the future. 3119 ''' 3120 deadline = None if timeout is None else time.time() + timeout 3121 req = ManagedSecretLogsRequest() 3122 req.meta.CopyFrom(ListRequestMetadata()) 3123 if self.parent.page_limit > 0: 3124 req.meta.limit = self.parent.page_limit 3125 if self.parent.snapshot_datetime is not None: 3126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3127 3128 req.filter = plumbing.quote_filter_args(filter, *args) 3129 3130 def generator(svc, req): 3131 tries = 0 3132 while True: 3133 t = None if deadline is None else deadline - time.time() 3134 try: 3135 plumbing_response = svc.stub.Logs( 3136 req, 3137 metadata=svc.parent.get_metadata( 3138 'ManagedSecrets.Logs', req), 3139 timeout=t) 3140 except Exception as e: 3141 if self.parent.shouldRetry(tries, e, deadline): 3142 tries += 1 3143 time.sleep( 3144 self.parent.exponentialBackoff(tries, deadline)) 3145 continue 3146 raise plumbing.convert_error_to_porcelain(e) from e 3147 tries = 0 3148 for plumbing_item in plumbing_response.managed_secret_logs: 3149 yield plumbing.convert_managed_secret_log_to_porcelain( 3150 plumbing_item) 3151 if plumbing_response.meta.next_cursor == '': 3152 break 3153 req.meta.cursor = plumbing_response.meta.next_cursor 3154 3155 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
3158class Nodes: 3159 ''' 3160 Nodes make up the strongDM network, and allow your users to connect securely to your resources. There are two types of nodes: 3161 - **Gateways** are the entry points into network. They listen for connection from the strongDM client, and provide access to databases and servers. 3162 - **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. 3163 See: 3164 `strongdm.models.Gateway` 3165 `strongdm.models.ProxyCluster` 3166 `strongdm.models.Relay` 3167 ''' 3168 def __init__(self, channel, client): 3169 self.parent = client 3170 self.stub = NodesStub(channel) 3171 3172 def create(self, node, timeout=None): 3173 ''' 3174 Create registers a new Node. 3175 ''' 3176 deadline = None if timeout is None else time.time() + timeout 3177 req = NodeCreateRequest() 3178 3179 if node is not None: 3180 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3181 tries = 0 3182 plumbing_response = None 3183 while True: 3184 t = None if deadline is None else deadline - time.time() 3185 try: 3186 plumbing_response = self.stub.Create( 3187 req, 3188 metadata=self.parent.get_metadata('Nodes.Create', req), 3189 timeout=t) 3190 except Exception as e: 3191 if self.parent.shouldRetry(tries, e, deadline): 3192 tries += 1 3193 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3194 continue 3195 raise plumbing.convert_error_to_porcelain(e) from e 3196 break 3197 3198 resp = models.NodeCreateResponse() 3199 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3200 plumbing_response.meta) 3201 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3203 plumbing_response.rate_limit) 3204 resp.token = (plumbing_response.token) 3205 return resp 3206 3207 def get(self, id, timeout=None): 3208 ''' 3209 Get reads one Node by ID. 3210 ''' 3211 deadline = None if timeout is None else time.time() + timeout 3212 req = NodeGetRequest() 3213 if self.parent.snapshot_datetime is not None: 3214 req.meta.CopyFrom(GetRequestMetadata()) 3215 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3216 3217 req.id = (id) 3218 tries = 0 3219 plumbing_response = None 3220 while True: 3221 t = None if deadline is None else deadline - time.time() 3222 try: 3223 plumbing_response = self.stub.Get( 3224 req, 3225 metadata=self.parent.get_metadata('Nodes.Get', req), 3226 timeout=t) 3227 except Exception as e: 3228 if self.parent.shouldRetry(tries, e, deadline): 3229 tries += 1 3230 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3231 continue 3232 raise plumbing.convert_error_to_porcelain(e) from e 3233 break 3234 3235 resp = models.NodeGetResponse() 3236 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3237 plumbing_response.meta) 3238 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3240 plumbing_response.rate_limit) 3241 return resp 3242 3243 def update(self, node, timeout=None): 3244 ''' 3245 Update replaces all the fields of a Node by ID. 3246 ''' 3247 deadline = None if timeout is None else time.time() + timeout 3248 req = NodeUpdateRequest() 3249 3250 if node is not None: 3251 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3252 tries = 0 3253 plumbing_response = None 3254 while True: 3255 t = None if deadline is None else deadline - time.time() 3256 try: 3257 plumbing_response = self.stub.Update( 3258 req, 3259 metadata=self.parent.get_metadata('Nodes.Update', req), 3260 timeout=t) 3261 except Exception as e: 3262 if self.parent.shouldRetry(tries, e, deadline): 3263 tries += 1 3264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3265 continue 3266 raise plumbing.convert_error_to_porcelain(e) from e 3267 break 3268 3269 resp = models.NodeUpdateResponse() 3270 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3271 plumbing_response.meta) 3272 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3273 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3274 plumbing_response.rate_limit) 3275 return resp 3276 3277 def delete(self, id, timeout=None): 3278 ''' 3279 Delete removes a Node by ID. 3280 ''' 3281 deadline = None if timeout is None else time.time() + timeout 3282 req = NodeDeleteRequest() 3283 3284 req.id = (id) 3285 tries = 0 3286 plumbing_response = None 3287 while True: 3288 t = None if deadline is None else deadline - time.time() 3289 try: 3290 plumbing_response = self.stub.Delete( 3291 req, 3292 metadata=self.parent.get_metadata('Nodes.Delete', req), 3293 timeout=t) 3294 except Exception as e: 3295 if self.parent.shouldRetry(tries, e, deadline): 3296 tries += 1 3297 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3298 continue 3299 raise plumbing.convert_error_to_porcelain(e) from e 3300 break 3301 3302 resp = models.NodeDeleteResponse() 3303 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3304 plumbing_response.meta) 3305 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3306 plumbing_response.rate_limit) 3307 return resp 3308 3309 def list(self, filter, *args, timeout=None): 3310 ''' 3311 List gets a list of Nodes matching a given set of criteria. 3312 ''' 3313 deadline = None if timeout is None else time.time() + timeout 3314 req = NodeListRequest() 3315 req.meta.CopyFrom(ListRequestMetadata()) 3316 if self.parent.page_limit > 0: 3317 req.meta.limit = self.parent.page_limit 3318 if self.parent.snapshot_datetime is not None: 3319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3320 3321 req.filter = plumbing.quote_filter_args(filter, *args) 3322 3323 def generator(svc, req): 3324 tries = 0 3325 while True: 3326 t = None if deadline is None else deadline - time.time() 3327 try: 3328 plumbing_response = svc.stub.List( 3329 req, 3330 metadata=svc.parent.get_metadata('Nodes.List', req), 3331 timeout=t) 3332 except Exception as e: 3333 if self.parent.shouldRetry(tries, e, deadline): 3334 tries += 1 3335 time.sleep( 3336 self.parent.exponentialBackoff(tries, deadline)) 3337 continue 3338 raise plumbing.convert_error_to_porcelain(e) from e 3339 tries = 0 3340 for plumbing_item in plumbing_response.nodes: 3341 yield plumbing.convert_node_to_porcelain(plumbing_item) 3342 if plumbing_response.meta.next_cursor == '': 3343 break 3344 req.meta.cursor = plumbing_response.meta.next_cursor 3345 3346 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)
3172 def create(self, node, timeout=None): 3173 ''' 3174 Create registers a new Node. 3175 ''' 3176 deadline = None if timeout is None else time.time() + timeout 3177 req = NodeCreateRequest() 3178 3179 if node is not None: 3180 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3181 tries = 0 3182 plumbing_response = None 3183 while True: 3184 t = None if deadline is None else deadline - time.time() 3185 try: 3186 plumbing_response = self.stub.Create( 3187 req, 3188 metadata=self.parent.get_metadata('Nodes.Create', req), 3189 timeout=t) 3190 except Exception as e: 3191 if self.parent.shouldRetry(tries, e, deadline): 3192 tries += 1 3193 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3194 continue 3195 raise plumbing.convert_error_to_porcelain(e) from e 3196 break 3197 3198 resp = models.NodeCreateResponse() 3199 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3200 plumbing_response.meta) 3201 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3203 plumbing_response.rate_limit) 3204 resp.token = (plumbing_response.token) 3205 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
3207 def get(self, id, timeout=None): 3208 ''' 3209 Get reads one Node by ID. 3210 ''' 3211 deadline = None if timeout is None else time.time() + timeout 3212 req = NodeGetRequest() 3213 if self.parent.snapshot_datetime is not None: 3214 req.meta.CopyFrom(GetRequestMetadata()) 3215 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3216 3217 req.id = (id) 3218 tries = 0 3219 plumbing_response = None 3220 while True: 3221 t = None if deadline is None else deadline - time.time() 3222 try: 3223 plumbing_response = self.stub.Get( 3224 req, 3225 metadata=self.parent.get_metadata('Nodes.Get', req), 3226 timeout=t) 3227 except Exception as e: 3228 if self.parent.shouldRetry(tries, e, deadline): 3229 tries += 1 3230 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3231 continue 3232 raise plumbing.convert_error_to_porcelain(e) from e 3233 break 3234 3235 resp = models.NodeGetResponse() 3236 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3237 plumbing_response.meta) 3238 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3240 plumbing_response.rate_limit) 3241 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
3243 def update(self, node, timeout=None): 3244 ''' 3245 Update replaces all the fields of a Node by ID. 3246 ''' 3247 deadline = None if timeout is None else time.time() + timeout 3248 req = NodeUpdateRequest() 3249 3250 if node is not None: 3251 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 3252 tries = 0 3253 plumbing_response = None 3254 while True: 3255 t = None if deadline is None else deadline - time.time() 3256 try: 3257 plumbing_response = self.stub.Update( 3258 req, 3259 metadata=self.parent.get_metadata('Nodes.Update', req), 3260 timeout=t) 3261 except Exception as e: 3262 if self.parent.shouldRetry(tries, e, deadline): 3263 tries += 1 3264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3265 continue 3266 raise plumbing.convert_error_to_porcelain(e) from e 3267 break 3268 3269 resp = models.NodeUpdateResponse() 3270 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3271 plumbing_response.meta) 3272 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 3273 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3274 plumbing_response.rate_limit) 3275 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
3277 def delete(self, id, timeout=None): 3278 ''' 3279 Delete removes a Node by ID. 3280 ''' 3281 deadline = None if timeout is None else time.time() + timeout 3282 req = NodeDeleteRequest() 3283 3284 req.id = (id) 3285 tries = 0 3286 plumbing_response = None 3287 while True: 3288 t = None if deadline is None else deadline - time.time() 3289 try: 3290 plumbing_response = self.stub.Delete( 3291 req, 3292 metadata=self.parent.get_metadata('Nodes.Delete', req), 3293 timeout=t) 3294 except Exception as e: 3295 if self.parent.shouldRetry(tries, e, deadline): 3296 tries += 1 3297 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3298 continue 3299 raise plumbing.convert_error_to_porcelain(e) from e 3300 break 3301 3302 resp = models.NodeDeleteResponse() 3303 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3304 plumbing_response.meta) 3305 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3306 plumbing_response.rate_limit) 3307 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
3309 def list(self, filter, *args, timeout=None): 3310 ''' 3311 List gets a list of Nodes matching a given set of criteria. 3312 ''' 3313 deadline = None if timeout is None else time.time() + timeout 3314 req = NodeListRequest() 3315 req.meta.CopyFrom(ListRequestMetadata()) 3316 if self.parent.page_limit > 0: 3317 req.meta.limit = self.parent.page_limit 3318 if self.parent.snapshot_datetime is not None: 3319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3320 3321 req.filter = plumbing.quote_filter_args(filter, *args) 3322 3323 def generator(svc, req): 3324 tries = 0 3325 while True: 3326 t = None if deadline is None else deadline - time.time() 3327 try: 3328 plumbing_response = svc.stub.List( 3329 req, 3330 metadata=svc.parent.get_metadata('Nodes.List', req), 3331 timeout=t) 3332 except Exception as e: 3333 if self.parent.shouldRetry(tries, e, deadline): 3334 tries += 1 3335 time.sleep( 3336 self.parent.exponentialBackoff(tries, deadline)) 3337 continue 3338 raise plumbing.convert_error_to_porcelain(e) from e 3339 tries = 0 3340 for plumbing_item in plumbing_response.nodes: 3341 yield plumbing.convert_node_to_porcelain(plumbing_item) 3342 if plumbing_response.meta.next_cursor == '': 3343 break 3344 req.meta.cursor = plumbing_response.meta.next_cursor 3345 3346 return generator(self, req)
List gets a list of Nodes matching a given set of criteria.
class
SnapshotNodes:
3349class SnapshotNodes: 3350 ''' 3351 SnapshotNodes exposes the read only methods of the Nodes 3352 service for historical queries. 3353 ''' 3354 def __init__(self, nodes): 3355 self.nodes = nodes 3356 3357 def get(self, id, timeout=None): 3358 ''' 3359 Get reads one Node by ID. 3360 ''' 3361 return self.nodes.get(id, timeout=timeout) 3362 3363 def list(self, filter, *args, timeout=None): 3364 ''' 3365 List gets a list of Nodes matching a given set of criteria. 3366 ''' 3367 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
3370class NodesHistory: 3371 ''' 3372 NodesHistory records all changes to the state of a Node. 3373 See `strongdm.models.NodeHistory`. 3374 ''' 3375 def __init__(self, channel, client): 3376 self.parent = client 3377 self.stub = NodesHistoryStub(channel) 3378 3379 def list(self, filter, *args, timeout=None): 3380 ''' 3381 List gets a list of NodeHistory records matching a given set of criteria. 3382 ''' 3383 deadline = None if timeout is None else time.time() + timeout 3384 req = NodeHistoryListRequest() 3385 req.meta.CopyFrom(ListRequestMetadata()) 3386 if self.parent.page_limit > 0: 3387 req.meta.limit = self.parent.page_limit 3388 if self.parent.snapshot_datetime is not None: 3389 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3390 3391 req.filter = plumbing.quote_filter_args(filter, *args) 3392 3393 def generator(svc, req): 3394 tries = 0 3395 while True: 3396 t = None if deadline is None else deadline - time.time() 3397 try: 3398 plumbing_response = svc.stub.List( 3399 req, 3400 metadata=svc.parent.get_metadata( 3401 'NodesHistory.List', req), 3402 timeout=t) 3403 except Exception as e: 3404 if self.parent.shouldRetry(tries, e, deadline): 3405 tries += 1 3406 time.sleep( 3407 self.parent.exponentialBackoff(tries, deadline)) 3408 continue 3409 raise plumbing.convert_error_to_porcelain(e) from e 3410 tries = 0 3411 for plumbing_item in plumbing_response.history: 3412 yield plumbing.convert_node_history_to_porcelain( 3413 plumbing_item) 3414 if plumbing_response.meta.next_cursor == '': 3415 break 3416 req.meta.cursor = plumbing_response.meta.next_cursor 3417 3418 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)
3379 def list(self, filter, *args, timeout=None): 3380 ''' 3381 List gets a list of NodeHistory records matching a given set of criteria. 3382 ''' 3383 deadline = None if timeout is None else time.time() + timeout 3384 req = NodeHistoryListRequest() 3385 req.meta.CopyFrom(ListRequestMetadata()) 3386 if self.parent.page_limit > 0: 3387 req.meta.limit = self.parent.page_limit 3388 if self.parent.snapshot_datetime is not None: 3389 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3390 3391 req.filter = plumbing.quote_filter_args(filter, *args) 3392 3393 def generator(svc, req): 3394 tries = 0 3395 while True: 3396 t = None if deadline is None else deadline - time.time() 3397 try: 3398 plumbing_response = svc.stub.List( 3399 req, 3400 metadata=svc.parent.get_metadata( 3401 'NodesHistory.List', req), 3402 timeout=t) 3403 except Exception as e: 3404 if self.parent.shouldRetry(tries, e, deadline): 3405 tries += 1 3406 time.sleep( 3407 self.parent.exponentialBackoff(tries, deadline)) 3408 continue 3409 raise plumbing.convert_error_to_porcelain(e) from e 3410 tries = 0 3411 for plumbing_item in plumbing_response.history: 3412 yield plumbing.convert_node_history_to_porcelain( 3413 plumbing_item) 3414 if plumbing_response.meta.next_cursor == '': 3415 break 3416 req.meta.cursor = plumbing_response.meta.next_cursor 3417 3418 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
3421class OrganizationHistory: 3422 ''' 3423 OrganizationHistory records all changes to the state of an Organization. 3424 See `strongdm.models.OrganizationHistoryRecord`. 3425 ''' 3426 def __init__(self, channel, client): 3427 self.parent = client 3428 self.stub = OrganizationHistoryStub(channel) 3429 3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of OrganizationHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = OrganizationHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'OrganizationHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_organization_history_record_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 return generator(self, req)
OrganizationHistory records all changes to the state of an Organization.
See strongdm.models.OrganizationHistoryRecord.
def
list(self, filter, *args, timeout=None)
3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of OrganizationHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = OrganizationHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'OrganizationHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_organization_history_record_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
3472class PeeringGroupNodes: 3473 ''' 3474 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 3475 See `strongdm.models.PeeringGroupNode`. 3476 ''' 3477 def __init__(self, channel, client): 3478 self.parent = client 3479 self.stub = PeeringGroupNodesStub(channel) 3480 3481 def create(self, peering_group_node, timeout=None): 3482 ''' 3483 Create attaches a Node to a PeeringGroup 3484 ''' 3485 deadline = None if timeout is None else time.time() + timeout 3486 req = PeeringGroupNodeCreateRequest() 3487 3488 if peering_group_node is not None: 3489 req.peering_group_node.CopyFrom( 3490 plumbing.convert_peering_group_node_to_plumbing( 3491 peering_group_node)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata( 3500 'PeeringGroupNodes.Create', req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.PeeringGroupNodeCreateResponse() 3511 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3512 plumbing_response.meta) 3513 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3514 plumbing_response.peering_group_node) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp 3518 3519 def delete(self, id, timeout=None): 3520 ''' 3521 Delete detaches a Node to a PeeringGroup. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = PeeringGroupNodeDeleteRequest() 3525 3526 req.id = (id) 3527 tries = 0 3528 plumbing_response = None 3529 while True: 3530 t = None if deadline is None else deadline - time.time() 3531 try: 3532 plumbing_response = self.stub.Delete( 3533 req, 3534 metadata=self.parent.get_metadata( 3535 'PeeringGroupNodes.Delete', req), 3536 timeout=t) 3537 except Exception as e: 3538 if self.parent.shouldRetry(tries, e, deadline): 3539 tries += 1 3540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3541 continue 3542 raise plumbing.convert_error_to_porcelain(e) from e 3543 break 3544 3545 resp = models.PeeringGroupNodeDeleteResponse() 3546 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3547 plumbing_response.meta) 3548 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3549 plumbing_response.rate_limit) 3550 return resp 3551 3552 def get(self, id, timeout=None): 3553 ''' 3554 Get reads the information of one peering group to node attachment. 3555 ''' 3556 deadline = None if timeout is None else time.time() + timeout 3557 req = PeeringGroupNodeGetRequest() 3558 if self.parent.snapshot_datetime is not None: 3559 req.meta.CopyFrom(GetRequestMetadata()) 3560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3561 3562 req.id = (id) 3563 tries = 0 3564 plumbing_response = None 3565 while True: 3566 t = None if deadline is None else deadline - time.time() 3567 try: 3568 plumbing_response = self.stub.Get( 3569 req, 3570 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3571 req), 3572 timeout=t) 3573 except Exception as e: 3574 if self.parent.shouldRetry(tries, e, deadline): 3575 tries += 1 3576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3577 continue 3578 raise plumbing.convert_error_to_porcelain(e) from e 3579 break 3580 3581 resp = models.PeeringGroupNodeGetResponse() 3582 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3583 plumbing_response.meta) 3584 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3585 plumbing_response.peering_group_node) 3586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3587 plumbing_response.rate_limit) 3588 return resp 3589 3590 def list(self, filter, *args, timeout=None): 3591 ''' 3592 List gets a list of peering group node attachments. 3593 ''' 3594 deadline = None if timeout is None else time.time() + timeout 3595 req = PeeringGroupNodeListRequest() 3596 req.meta.CopyFrom(ListRequestMetadata()) 3597 if self.parent.page_limit > 0: 3598 req.meta.limit = self.parent.page_limit 3599 if self.parent.snapshot_datetime is not None: 3600 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3601 3602 req.filter = plumbing.quote_filter_args(filter, *args) 3603 3604 def generator(svc, req): 3605 tries = 0 3606 while True: 3607 t = None if deadline is None else deadline - time.time() 3608 try: 3609 plumbing_response = svc.stub.List( 3610 req, 3611 metadata=svc.parent.get_metadata( 3612 'PeeringGroupNodes.List', req), 3613 timeout=t) 3614 except Exception as e: 3615 if self.parent.shouldRetry(tries, e, deadline): 3616 tries += 1 3617 time.sleep( 3618 self.parent.exponentialBackoff(tries, deadline)) 3619 continue 3620 raise plumbing.convert_error_to_porcelain(e) from e 3621 tries = 0 3622 for plumbing_item in plumbing_response.peering_group_nodes: 3623 yield plumbing.convert_peering_group_node_to_porcelain( 3624 plumbing_item) 3625 if plumbing_response.meta.next_cursor == '': 3626 break 3627 req.meta.cursor = plumbing_response.meta.next_cursor 3628 3629 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)
3481 def create(self, peering_group_node, timeout=None): 3482 ''' 3483 Create attaches a Node to a PeeringGroup 3484 ''' 3485 deadline = None if timeout is None else time.time() + timeout 3486 req = PeeringGroupNodeCreateRequest() 3487 3488 if peering_group_node is not None: 3489 req.peering_group_node.CopyFrom( 3490 plumbing.convert_peering_group_node_to_plumbing( 3491 peering_group_node)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata( 3500 'PeeringGroupNodes.Create', req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.PeeringGroupNodeCreateResponse() 3511 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3512 plumbing_response.meta) 3513 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3514 plumbing_response.peering_group_node) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
3519 def delete(self, id, timeout=None): 3520 ''' 3521 Delete detaches a Node to a PeeringGroup. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = PeeringGroupNodeDeleteRequest() 3525 3526 req.id = (id) 3527 tries = 0 3528 plumbing_response = None 3529 while True: 3530 t = None if deadline is None else deadline - time.time() 3531 try: 3532 plumbing_response = self.stub.Delete( 3533 req, 3534 metadata=self.parent.get_metadata( 3535 'PeeringGroupNodes.Delete', req), 3536 timeout=t) 3537 except Exception as e: 3538 if self.parent.shouldRetry(tries, e, deadline): 3539 tries += 1 3540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3541 continue 3542 raise plumbing.convert_error_to_porcelain(e) from e 3543 break 3544 3545 resp = models.PeeringGroupNodeDeleteResponse() 3546 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3547 plumbing_response.meta) 3548 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3549 plumbing_response.rate_limit) 3550 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
3552 def get(self, id, timeout=None): 3553 ''' 3554 Get reads the information of one peering group to node attachment. 3555 ''' 3556 deadline = None if timeout is None else time.time() + timeout 3557 req = PeeringGroupNodeGetRequest() 3558 if self.parent.snapshot_datetime is not None: 3559 req.meta.CopyFrom(GetRequestMetadata()) 3560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3561 3562 req.id = (id) 3563 tries = 0 3564 plumbing_response = None 3565 while True: 3566 t = None if deadline is None else deadline - time.time() 3567 try: 3568 plumbing_response = self.stub.Get( 3569 req, 3570 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 3571 req), 3572 timeout=t) 3573 except Exception as e: 3574 if self.parent.shouldRetry(tries, e, deadline): 3575 tries += 1 3576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3577 continue 3578 raise plumbing.convert_error_to_porcelain(e) from e 3579 break 3580 3581 resp = models.PeeringGroupNodeGetResponse() 3582 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3583 plumbing_response.meta) 3584 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 3585 plumbing_response.peering_group_node) 3586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3587 plumbing_response.rate_limit) 3588 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
3590 def list(self, filter, *args, timeout=None): 3591 ''' 3592 List gets a list of peering group node attachments. 3593 ''' 3594 deadline = None if timeout is None else time.time() + timeout 3595 req = PeeringGroupNodeListRequest() 3596 req.meta.CopyFrom(ListRequestMetadata()) 3597 if self.parent.page_limit > 0: 3598 req.meta.limit = self.parent.page_limit 3599 if self.parent.snapshot_datetime is not None: 3600 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3601 3602 req.filter = plumbing.quote_filter_args(filter, *args) 3603 3604 def generator(svc, req): 3605 tries = 0 3606 while True: 3607 t = None if deadline is None else deadline - time.time() 3608 try: 3609 plumbing_response = svc.stub.List( 3610 req, 3611 metadata=svc.parent.get_metadata( 3612 'PeeringGroupNodes.List', req), 3613 timeout=t) 3614 except Exception as e: 3615 if self.parent.shouldRetry(tries, e, deadline): 3616 tries += 1 3617 time.sleep( 3618 self.parent.exponentialBackoff(tries, deadline)) 3619 continue 3620 raise plumbing.convert_error_to_porcelain(e) from e 3621 tries = 0 3622 for plumbing_item in plumbing_response.peering_group_nodes: 3623 yield plumbing.convert_peering_group_node_to_porcelain( 3624 plumbing_item) 3625 if plumbing_response.meta.next_cursor == '': 3626 break 3627 req.meta.cursor = plumbing_response.meta.next_cursor 3628 3629 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
3632class PeeringGroupPeers: 3633 ''' 3634 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 3635 See `strongdm.models.PeeringGroupPeer`. 3636 ''' 3637 def __init__(self, channel, client): 3638 self.parent = client 3639 self.stub = PeeringGroupPeersStub(channel) 3640 3641 def create(self, peering_group_peer, timeout=None): 3642 ''' 3643 Create links two peering groups. 3644 ''' 3645 deadline = None if timeout is None else time.time() + timeout 3646 req = PeeringGroupPeerCreateRequest() 3647 3648 if peering_group_peer is not None: 3649 req.peering_group_peer.CopyFrom( 3650 plumbing.convert_peering_group_peer_to_plumbing( 3651 peering_group_peer)) 3652 tries = 0 3653 plumbing_response = None 3654 while True: 3655 t = None if deadline is None else deadline - time.time() 3656 try: 3657 plumbing_response = self.stub.Create( 3658 req, 3659 metadata=self.parent.get_metadata( 3660 'PeeringGroupPeers.Create', req), 3661 timeout=t) 3662 except Exception as e: 3663 if self.parent.shouldRetry(tries, e, deadline): 3664 tries += 1 3665 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3666 continue 3667 raise plumbing.convert_error_to_porcelain(e) from e 3668 break 3669 3670 resp = models.PeeringGroupPeerCreateResponse() 3671 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3672 plumbing_response.meta) 3673 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3674 plumbing_response.peering_group_peer) 3675 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3676 plumbing_response.rate_limit) 3677 return resp 3678 3679 def delete(self, id, timeout=None): 3680 ''' 3681 Delete unlinks two peering groups. 3682 ''' 3683 deadline = None if timeout is None else time.time() + timeout 3684 req = PeeringGroupPeerDeleteRequest() 3685 3686 req.id = (id) 3687 tries = 0 3688 plumbing_response = None 3689 while True: 3690 t = None if deadline is None else deadline - time.time() 3691 try: 3692 plumbing_response = self.stub.Delete( 3693 req, 3694 metadata=self.parent.get_metadata( 3695 'PeeringGroupPeers.Delete', req), 3696 timeout=t) 3697 except Exception as e: 3698 if self.parent.shouldRetry(tries, e, deadline): 3699 tries += 1 3700 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3701 continue 3702 raise plumbing.convert_error_to_porcelain(e) from e 3703 break 3704 3705 resp = models.PeeringGroupPeerDeleteResponse() 3706 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3707 plumbing_response.meta) 3708 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3709 plumbing_response.rate_limit) 3710 return resp 3711 3712 def get(self, id, timeout=None): 3713 ''' 3714 Get reads the information of one peering group link. 3715 ''' 3716 deadline = None if timeout is None else time.time() + timeout 3717 req = PeeringGroupPeerGetRequest() 3718 if self.parent.snapshot_datetime is not None: 3719 req.meta.CopyFrom(GetRequestMetadata()) 3720 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3721 3722 req.id = (id) 3723 tries = 0 3724 plumbing_response = None 3725 while True: 3726 t = None if deadline is None else deadline - time.time() 3727 try: 3728 plumbing_response = self.stub.Get( 3729 req, 3730 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3731 req), 3732 timeout=t) 3733 except Exception as e: 3734 if self.parent.shouldRetry(tries, e, deadline): 3735 tries += 1 3736 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3737 continue 3738 raise plumbing.convert_error_to_porcelain(e) from e 3739 break 3740 3741 resp = models.PeeringGroupPeerGetResponse() 3742 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3743 plumbing_response.meta) 3744 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3745 plumbing_response.peering_group_peer) 3746 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3747 plumbing_response.rate_limit) 3748 return resp 3749 3750 def list(self, filter, *args, timeout=None): 3751 ''' 3752 List gets a list of peering group links. 3753 ''' 3754 deadline = None if timeout is None else time.time() + timeout 3755 req = PeeringGroupPeerListRequest() 3756 req.meta.CopyFrom(ListRequestMetadata()) 3757 if self.parent.page_limit > 0: 3758 req.meta.limit = self.parent.page_limit 3759 if self.parent.snapshot_datetime is not None: 3760 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3761 3762 req.filter = plumbing.quote_filter_args(filter, *args) 3763 3764 def generator(svc, req): 3765 tries = 0 3766 while True: 3767 t = None if deadline is None else deadline - time.time() 3768 try: 3769 plumbing_response = svc.stub.List( 3770 req, 3771 metadata=svc.parent.get_metadata( 3772 'PeeringGroupPeers.List', req), 3773 timeout=t) 3774 except Exception as e: 3775 if self.parent.shouldRetry(tries, e, deadline): 3776 tries += 1 3777 time.sleep( 3778 self.parent.exponentialBackoff(tries, deadline)) 3779 continue 3780 raise plumbing.convert_error_to_porcelain(e) from e 3781 tries = 0 3782 for plumbing_item in plumbing_response.peering_group_peers: 3783 yield plumbing.convert_peering_group_peer_to_porcelain( 3784 plumbing_item) 3785 if plumbing_response.meta.next_cursor == '': 3786 break 3787 req.meta.cursor = plumbing_response.meta.next_cursor 3788 3789 return generator(self, req)
PeeringGroupPeers provides the building blocks necessary to link two peering groups.
See strongdm.models.PeeringGroupPeer.
def
create(self, peering_group_peer, timeout=None)
3641 def create(self, peering_group_peer, timeout=None): 3642 ''' 3643 Create links two peering groups. 3644 ''' 3645 deadline = None if timeout is None else time.time() + timeout 3646 req = PeeringGroupPeerCreateRequest() 3647 3648 if peering_group_peer is not None: 3649 req.peering_group_peer.CopyFrom( 3650 plumbing.convert_peering_group_peer_to_plumbing( 3651 peering_group_peer)) 3652 tries = 0 3653 plumbing_response = None 3654 while True: 3655 t = None if deadline is None else deadline - time.time() 3656 try: 3657 plumbing_response = self.stub.Create( 3658 req, 3659 metadata=self.parent.get_metadata( 3660 'PeeringGroupPeers.Create', req), 3661 timeout=t) 3662 except Exception as e: 3663 if self.parent.shouldRetry(tries, e, deadline): 3664 tries += 1 3665 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3666 continue 3667 raise plumbing.convert_error_to_porcelain(e) from e 3668 break 3669 3670 resp = models.PeeringGroupPeerCreateResponse() 3671 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3672 plumbing_response.meta) 3673 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3674 plumbing_response.peering_group_peer) 3675 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3676 plumbing_response.rate_limit) 3677 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
3679 def delete(self, id, timeout=None): 3680 ''' 3681 Delete unlinks two peering groups. 3682 ''' 3683 deadline = None if timeout is None else time.time() + timeout 3684 req = PeeringGroupPeerDeleteRequest() 3685 3686 req.id = (id) 3687 tries = 0 3688 plumbing_response = None 3689 while True: 3690 t = None if deadline is None else deadline - time.time() 3691 try: 3692 plumbing_response = self.stub.Delete( 3693 req, 3694 metadata=self.parent.get_metadata( 3695 'PeeringGroupPeers.Delete', req), 3696 timeout=t) 3697 except Exception as e: 3698 if self.parent.shouldRetry(tries, e, deadline): 3699 tries += 1 3700 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3701 continue 3702 raise plumbing.convert_error_to_porcelain(e) from e 3703 break 3704 3705 resp = models.PeeringGroupPeerDeleteResponse() 3706 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3707 plumbing_response.meta) 3708 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3709 plumbing_response.rate_limit) 3710 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
3712 def get(self, id, timeout=None): 3713 ''' 3714 Get reads the information of one peering group link. 3715 ''' 3716 deadline = None if timeout is None else time.time() + timeout 3717 req = PeeringGroupPeerGetRequest() 3718 if self.parent.snapshot_datetime is not None: 3719 req.meta.CopyFrom(GetRequestMetadata()) 3720 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3721 3722 req.id = (id) 3723 tries = 0 3724 plumbing_response = None 3725 while True: 3726 t = None if deadline is None else deadline - time.time() 3727 try: 3728 plumbing_response = self.stub.Get( 3729 req, 3730 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 3731 req), 3732 timeout=t) 3733 except Exception as e: 3734 if self.parent.shouldRetry(tries, e, deadline): 3735 tries += 1 3736 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3737 continue 3738 raise plumbing.convert_error_to_porcelain(e) from e 3739 break 3740 3741 resp = models.PeeringGroupPeerGetResponse() 3742 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3743 plumbing_response.meta) 3744 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 3745 plumbing_response.peering_group_peer) 3746 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3747 plumbing_response.rate_limit) 3748 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
3750 def list(self, filter, *args, timeout=None): 3751 ''' 3752 List gets a list of peering group links. 3753 ''' 3754 deadline = None if timeout is None else time.time() + timeout 3755 req = PeeringGroupPeerListRequest() 3756 req.meta.CopyFrom(ListRequestMetadata()) 3757 if self.parent.page_limit > 0: 3758 req.meta.limit = self.parent.page_limit 3759 if self.parent.snapshot_datetime is not None: 3760 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3761 3762 req.filter = plumbing.quote_filter_args(filter, *args) 3763 3764 def generator(svc, req): 3765 tries = 0 3766 while True: 3767 t = None if deadline is None else deadline - time.time() 3768 try: 3769 plumbing_response = svc.stub.List( 3770 req, 3771 metadata=svc.parent.get_metadata( 3772 'PeeringGroupPeers.List', req), 3773 timeout=t) 3774 except Exception as e: 3775 if self.parent.shouldRetry(tries, e, deadline): 3776 tries += 1 3777 time.sleep( 3778 self.parent.exponentialBackoff(tries, deadline)) 3779 continue 3780 raise plumbing.convert_error_to_porcelain(e) from e 3781 tries = 0 3782 for plumbing_item in plumbing_response.peering_group_peers: 3783 yield plumbing.convert_peering_group_peer_to_porcelain( 3784 plumbing_item) 3785 if plumbing_response.meta.next_cursor == '': 3786 break 3787 req.meta.cursor = plumbing_response.meta.next_cursor 3788 3789 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
3792class PeeringGroupResources: 3793 ''' 3794 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 3795 See `strongdm.models.PeeringGroupResource`. 3796 ''' 3797 def __init__(self, channel, client): 3798 self.parent = client 3799 self.stub = PeeringGroupResourcesStub(channel) 3800 3801 def create(self, peering_group_resource, timeout=None): 3802 ''' 3803 Create attaches a Resource to a PeeringGroup 3804 ''' 3805 deadline = None if timeout is None else time.time() + timeout 3806 req = PeeringGroupResourceCreateRequest() 3807 3808 if peering_group_resource is not None: 3809 req.peering_group_resource.CopyFrom( 3810 plumbing.convert_peering_group_resource_to_plumbing( 3811 peering_group_resource)) 3812 tries = 0 3813 plumbing_response = None 3814 while True: 3815 t = None if deadline is None else deadline - time.time() 3816 try: 3817 plumbing_response = self.stub.Create( 3818 req, 3819 metadata=self.parent.get_metadata( 3820 'PeeringGroupResources.Create', req), 3821 timeout=t) 3822 except Exception as e: 3823 if self.parent.shouldRetry(tries, e, deadline): 3824 tries += 1 3825 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3826 continue 3827 raise plumbing.convert_error_to_porcelain(e) from e 3828 break 3829 3830 resp = models.PeeringGroupResourceCreateResponse() 3831 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3832 plumbing_response.meta) 3833 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3834 plumbing_response.peering_group_resource) 3835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3836 plumbing_response.rate_limit) 3837 return resp 3838 3839 def delete(self, id, timeout=None): 3840 ''' 3841 Delete detaches a Resource to a PeeringGroup 3842 ''' 3843 deadline = None if timeout is None else time.time() + timeout 3844 req = PeeringGroupResourceDeleteRequest() 3845 3846 req.id = (id) 3847 tries = 0 3848 plumbing_response = None 3849 while True: 3850 t = None if deadline is None else deadline - time.time() 3851 try: 3852 plumbing_response = self.stub.Delete( 3853 req, 3854 metadata=self.parent.get_metadata( 3855 'PeeringGroupResources.Delete', req), 3856 timeout=t) 3857 except Exception as e: 3858 if self.parent.shouldRetry(tries, e, deadline): 3859 tries += 1 3860 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3861 continue 3862 raise plumbing.convert_error_to_porcelain(e) from e 3863 break 3864 3865 resp = models.PeeringGroupResourceDeleteResponse() 3866 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3867 plumbing_response.meta) 3868 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3869 plumbing_response.rate_limit) 3870 return resp 3871 3872 def get(self, id, timeout=None): 3873 ''' 3874 Get reads the information of one peering group to resource attachment. 3875 ''' 3876 deadline = None if timeout is None else time.time() + timeout 3877 req = PeeringGroupResourceGetRequest() 3878 if self.parent.snapshot_datetime is not None: 3879 req.meta.CopyFrom(GetRequestMetadata()) 3880 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3881 3882 req.id = (id) 3883 tries = 0 3884 plumbing_response = None 3885 while True: 3886 t = None if deadline is None else deadline - time.time() 3887 try: 3888 plumbing_response = self.stub.Get( 3889 req, 3890 metadata=self.parent.get_metadata( 3891 'PeeringGroupResources.Get', req), 3892 timeout=t) 3893 except Exception as e: 3894 if self.parent.shouldRetry(tries, e, deadline): 3895 tries += 1 3896 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3897 continue 3898 raise plumbing.convert_error_to_porcelain(e) from e 3899 break 3900 3901 resp = models.PeeringGroupResourceGetResponse() 3902 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3903 plumbing_response.meta) 3904 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3905 plumbing_response.peering_group_resource) 3906 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3907 plumbing_response.rate_limit) 3908 return resp 3909 3910 def list(self, filter, *args, timeout=None): 3911 ''' 3912 List gets a list of peering group resource attachments. 3913 ''' 3914 deadline = None if timeout is None else time.time() + timeout 3915 req = PeeringGroupResourceListRequest() 3916 req.meta.CopyFrom(ListRequestMetadata()) 3917 if self.parent.page_limit > 0: 3918 req.meta.limit = self.parent.page_limit 3919 if self.parent.snapshot_datetime is not None: 3920 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3921 3922 req.filter = plumbing.quote_filter_args(filter, *args) 3923 3924 def generator(svc, req): 3925 tries = 0 3926 while True: 3927 t = None if deadline is None else deadline - time.time() 3928 try: 3929 plumbing_response = svc.stub.List( 3930 req, 3931 metadata=svc.parent.get_metadata( 3932 'PeeringGroupResources.List', req), 3933 timeout=t) 3934 except Exception as e: 3935 if self.parent.shouldRetry(tries, e, deadline): 3936 tries += 1 3937 time.sleep( 3938 self.parent.exponentialBackoff(tries, deadline)) 3939 continue 3940 raise plumbing.convert_error_to_porcelain(e) from e 3941 tries = 0 3942 for plumbing_item in plumbing_response.peering_group_resources: 3943 yield plumbing.convert_peering_group_resource_to_porcelain( 3944 plumbing_item) 3945 if plumbing_response.meta.next_cursor == '': 3946 break 3947 req.meta.cursor = plumbing_response.meta.next_cursor 3948 3949 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)
3801 def create(self, peering_group_resource, timeout=None): 3802 ''' 3803 Create attaches a Resource to a PeeringGroup 3804 ''' 3805 deadline = None if timeout is None else time.time() + timeout 3806 req = PeeringGroupResourceCreateRequest() 3807 3808 if peering_group_resource is not None: 3809 req.peering_group_resource.CopyFrom( 3810 plumbing.convert_peering_group_resource_to_plumbing( 3811 peering_group_resource)) 3812 tries = 0 3813 plumbing_response = None 3814 while True: 3815 t = None if deadline is None else deadline - time.time() 3816 try: 3817 plumbing_response = self.stub.Create( 3818 req, 3819 metadata=self.parent.get_metadata( 3820 'PeeringGroupResources.Create', req), 3821 timeout=t) 3822 except Exception as e: 3823 if self.parent.shouldRetry(tries, e, deadline): 3824 tries += 1 3825 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3826 continue 3827 raise plumbing.convert_error_to_porcelain(e) from e 3828 break 3829 3830 resp = models.PeeringGroupResourceCreateResponse() 3831 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3832 plumbing_response.meta) 3833 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3834 plumbing_response.peering_group_resource) 3835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3836 plumbing_response.rate_limit) 3837 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
3839 def delete(self, id, timeout=None): 3840 ''' 3841 Delete detaches a Resource to a PeeringGroup 3842 ''' 3843 deadline = None if timeout is None else time.time() + timeout 3844 req = PeeringGroupResourceDeleteRequest() 3845 3846 req.id = (id) 3847 tries = 0 3848 plumbing_response = None 3849 while True: 3850 t = None if deadline is None else deadline - time.time() 3851 try: 3852 plumbing_response = self.stub.Delete( 3853 req, 3854 metadata=self.parent.get_metadata( 3855 'PeeringGroupResources.Delete', req), 3856 timeout=t) 3857 except Exception as e: 3858 if self.parent.shouldRetry(tries, e, deadline): 3859 tries += 1 3860 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3861 continue 3862 raise plumbing.convert_error_to_porcelain(e) from e 3863 break 3864 3865 resp = models.PeeringGroupResourceDeleteResponse() 3866 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3867 plumbing_response.meta) 3868 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3869 plumbing_response.rate_limit) 3870 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
3872 def get(self, id, timeout=None): 3873 ''' 3874 Get reads the information of one peering group to resource attachment. 3875 ''' 3876 deadline = None if timeout is None else time.time() + timeout 3877 req = PeeringGroupResourceGetRequest() 3878 if self.parent.snapshot_datetime is not None: 3879 req.meta.CopyFrom(GetRequestMetadata()) 3880 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3881 3882 req.id = (id) 3883 tries = 0 3884 plumbing_response = None 3885 while True: 3886 t = None if deadline is None else deadline - time.time() 3887 try: 3888 plumbing_response = self.stub.Get( 3889 req, 3890 metadata=self.parent.get_metadata( 3891 'PeeringGroupResources.Get', req), 3892 timeout=t) 3893 except Exception as e: 3894 if self.parent.shouldRetry(tries, e, deadline): 3895 tries += 1 3896 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3897 continue 3898 raise plumbing.convert_error_to_porcelain(e) from e 3899 break 3900 3901 resp = models.PeeringGroupResourceGetResponse() 3902 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3903 plumbing_response.meta) 3904 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 3905 plumbing_response.peering_group_resource) 3906 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3907 plumbing_response.rate_limit) 3908 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
3910 def list(self, filter, *args, timeout=None): 3911 ''' 3912 List gets a list of peering group resource attachments. 3913 ''' 3914 deadline = None if timeout is None else time.time() + timeout 3915 req = PeeringGroupResourceListRequest() 3916 req.meta.CopyFrom(ListRequestMetadata()) 3917 if self.parent.page_limit > 0: 3918 req.meta.limit = self.parent.page_limit 3919 if self.parent.snapshot_datetime is not None: 3920 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3921 3922 req.filter = plumbing.quote_filter_args(filter, *args) 3923 3924 def generator(svc, req): 3925 tries = 0 3926 while True: 3927 t = None if deadline is None else deadline - time.time() 3928 try: 3929 plumbing_response = svc.stub.List( 3930 req, 3931 metadata=svc.parent.get_metadata( 3932 'PeeringGroupResources.List', req), 3933 timeout=t) 3934 except Exception as e: 3935 if self.parent.shouldRetry(tries, e, deadline): 3936 tries += 1 3937 time.sleep( 3938 self.parent.exponentialBackoff(tries, deadline)) 3939 continue 3940 raise plumbing.convert_error_to_porcelain(e) from e 3941 tries = 0 3942 for plumbing_item in plumbing_response.peering_group_resources: 3943 yield plumbing.convert_peering_group_resource_to_porcelain( 3944 plumbing_item) 3945 if plumbing_response.meta.next_cursor == '': 3946 break 3947 req.meta.cursor = plumbing_response.meta.next_cursor 3948 3949 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
3952class PeeringGroups: 3953 ''' 3954 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 3955 See `strongdm.models.PeeringGroup`. 3956 ''' 3957 def __init__(self, channel, client): 3958 self.parent = client 3959 self.stub = PeeringGroupsStub(channel) 3960 3961 def create(self, peering_group, timeout=None): 3962 ''' 3963 Create registers a new PeeringGroup. 3964 ''' 3965 deadline = None if timeout is None else time.time() + timeout 3966 req = PeeringGroupCreateRequest() 3967 3968 if peering_group is not None: 3969 req.peering_group.CopyFrom( 3970 plumbing.convert_peering_group_to_plumbing(peering_group)) 3971 tries = 0 3972 plumbing_response = None 3973 while True: 3974 t = None if deadline is None else deadline - time.time() 3975 try: 3976 plumbing_response = self.stub.Create( 3977 req, 3978 metadata=self.parent.get_metadata('PeeringGroups.Create', 3979 req), 3980 timeout=t) 3981 except Exception as e: 3982 if self.parent.shouldRetry(tries, e, deadline): 3983 tries += 1 3984 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3985 continue 3986 raise plumbing.convert_error_to_porcelain(e) from e 3987 break 3988 3989 resp = models.PeeringGroupCreateResponse() 3990 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3991 plumbing_response.meta) 3992 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3993 plumbing_response.peering_group) 3994 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3995 plumbing_response.rate_limit) 3996 return resp 3997 3998 def delete(self, id, timeout=None): 3999 ''' 4000 Delete removes a PeeringGroup by ID. 4001 ''' 4002 deadline = None if timeout is None else time.time() + timeout 4003 req = PeeringGroupDeleteRequest() 4004 4005 req.id = (id) 4006 tries = 0 4007 plumbing_response = None 4008 while True: 4009 t = None if deadline is None else deadline - time.time() 4010 try: 4011 plumbing_response = self.stub.Delete( 4012 req, 4013 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4014 req), 4015 timeout=t) 4016 except Exception as e: 4017 if self.parent.shouldRetry(tries, e, deadline): 4018 tries += 1 4019 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4020 continue 4021 raise plumbing.convert_error_to_porcelain(e) from e 4022 break 4023 4024 resp = models.PeeringGroupDeleteResponse() 4025 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4026 plumbing_response.meta) 4027 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4028 plumbing_response.rate_limit) 4029 return resp 4030 4031 def get(self, id, timeout=None): 4032 ''' 4033 Get reads one PeeringGroup by ID. It will load all its dependencies. 4034 ''' 4035 deadline = None if timeout is None else time.time() + timeout 4036 req = PeeringGroupGetRequest() 4037 if self.parent.snapshot_datetime is not None: 4038 req.meta.CopyFrom(GetRequestMetadata()) 4039 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4040 4041 req.id = (id) 4042 tries = 0 4043 plumbing_response = None 4044 while True: 4045 t = None if deadline is None else deadline - time.time() 4046 try: 4047 plumbing_response = self.stub.Get( 4048 req, 4049 metadata=self.parent.get_metadata('PeeringGroups.Get', 4050 req), 4051 timeout=t) 4052 except Exception as e: 4053 if self.parent.shouldRetry(tries, e, deadline): 4054 tries += 1 4055 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4056 continue 4057 raise plumbing.convert_error_to_porcelain(e) from e 4058 break 4059 4060 resp = models.PeeringGroupGetResponse() 4061 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4062 plumbing_response.meta) 4063 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4064 plumbing_response.peering_group) 4065 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4066 plumbing_response.rate_limit) 4067 return resp 4068 4069 def list(self, filter, *args, timeout=None): 4070 ''' 4071 List gets a list of Peering Groups. 4072 ''' 4073 deadline = None if timeout is None else time.time() + timeout 4074 req = PeeringGroupListRequest() 4075 req.meta.CopyFrom(ListRequestMetadata()) 4076 if self.parent.page_limit > 0: 4077 req.meta.limit = self.parent.page_limit 4078 if self.parent.snapshot_datetime is not None: 4079 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4080 4081 req.filter = plumbing.quote_filter_args(filter, *args) 4082 4083 def generator(svc, req): 4084 tries = 0 4085 while True: 4086 t = None if deadline is None else deadline - time.time() 4087 try: 4088 plumbing_response = svc.stub.List( 4089 req, 4090 metadata=svc.parent.get_metadata( 4091 'PeeringGroups.List', req), 4092 timeout=t) 4093 except Exception as e: 4094 if self.parent.shouldRetry(tries, e, deadline): 4095 tries += 1 4096 time.sleep( 4097 self.parent.exponentialBackoff(tries, deadline)) 4098 continue 4099 raise plumbing.convert_error_to_porcelain(e) from e 4100 tries = 0 4101 for plumbing_item in plumbing_response.peering_groups: 4102 yield plumbing.convert_peering_group_to_porcelain( 4103 plumbing_item) 4104 if plumbing_response.meta.next_cursor == '': 4105 break 4106 req.meta.cursor = plumbing_response.meta.next_cursor 4107 4108 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)
3961 def create(self, peering_group, timeout=None): 3962 ''' 3963 Create registers a new PeeringGroup. 3964 ''' 3965 deadline = None if timeout is None else time.time() + timeout 3966 req = PeeringGroupCreateRequest() 3967 3968 if peering_group is not None: 3969 req.peering_group.CopyFrom( 3970 plumbing.convert_peering_group_to_plumbing(peering_group)) 3971 tries = 0 3972 plumbing_response = None 3973 while True: 3974 t = None if deadline is None else deadline - time.time() 3975 try: 3976 plumbing_response = self.stub.Create( 3977 req, 3978 metadata=self.parent.get_metadata('PeeringGroups.Create', 3979 req), 3980 timeout=t) 3981 except Exception as e: 3982 if self.parent.shouldRetry(tries, e, deadline): 3983 tries += 1 3984 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3985 continue 3986 raise plumbing.convert_error_to_porcelain(e) from e 3987 break 3988 3989 resp = models.PeeringGroupCreateResponse() 3990 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3991 plumbing_response.meta) 3992 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 3993 plumbing_response.peering_group) 3994 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3995 plumbing_response.rate_limit) 3996 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
3998 def delete(self, id, timeout=None): 3999 ''' 4000 Delete removes a PeeringGroup by ID. 4001 ''' 4002 deadline = None if timeout is None else time.time() + timeout 4003 req = PeeringGroupDeleteRequest() 4004 4005 req.id = (id) 4006 tries = 0 4007 plumbing_response = None 4008 while True: 4009 t = None if deadline is None else deadline - time.time() 4010 try: 4011 plumbing_response = self.stub.Delete( 4012 req, 4013 metadata=self.parent.get_metadata('PeeringGroups.Delete', 4014 req), 4015 timeout=t) 4016 except Exception as e: 4017 if self.parent.shouldRetry(tries, e, deadline): 4018 tries += 1 4019 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4020 continue 4021 raise plumbing.convert_error_to_porcelain(e) from e 4022 break 4023 4024 resp = models.PeeringGroupDeleteResponse() 4025 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4026 plumbing_response.meta) 4027 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4028 plumbing_response.rate_limit) 4029 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
4031 def get(self, id, timeout=None): 4032 ''' 4033 Get reads one PeeringGroup by ID. It will load all its dependencies. 4034 ''' 4035 deadline = None if timeout is None else time.time() + timeout 4036 req = PeeringGroupGetRequest() 4037 if self.parent.snapshot_datetime is not None: 4038 req.meta.CopyFrom(GetRequestMetadata()) 4039 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4040 4041 req.id = (id) 4042 tries = 0 4043 plumbing_response = None 4044 while True: 4045 t = None if deadline is None else deadline - time.time() 4046 try: 4047 plumbing_response = self.stub.Get( 4048 req, 4049 metadata=self.parent.get_metadata('PeeringGroups.Get', 4050 req), 4051 timeout=t) 4052 except Exception as e: 4053 if self.parent.shouldRetry(tries, e, deadline): 4054 tries += 1 4055 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4056 continue 4057 raise plumbing.convert_error_to_porcelain(e) from e 4058 break 4059 4060 resp = models.PeeringGroupGetResponse() 4061 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4062 plumbing_response.meta) 4063 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 4064 plumbing_response.peering_group) 4065 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4066 plumbing_response.rate_limit) 4067 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
4069 def list(self, filter, *args, timeout=None): 4070 ''' 4071 List gets a list of Peering Groups. 4072 ''' 4073 deadline = None if timeout is None else time.time() + timeout 4074 req = PeeringGroupListRequest() 4075 req.meta.CopyFrom(ListRequestMetadata()) 4076 if self.parent.page_limit > 0: 4077 req.meta.limit = self.parent.page_limit 4078 if self.parent.snapshot_datetime is not None: 4079 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4080 4081 req.filter = plumbing.quote_filter_args(filter, *args) 4082 4083 def generator(svc, req): 4084 tries = 0 4085 while True: 4086 t = None if deadline is None else deadline - time.time() 4087 try: 4088 plumbing_response = svc.stub.List( 4089 req, 4090 metadata=svc.parent.get_metadata( 4091 'PeeringGroups.List', req), 4092 timeout=t) 4093 except Exception as e: 4094 if self.parent.shouldRetry(tries, e, deadline): 4095 tries += 1 4096 time.sleep( 4097 self.parent.exponentialBackoff(tries, deadline)) 4098 continue 4099 raise plumbing.convert_error_to_porcelain(e) from e 4100 tries = 0 4101 for plumbing_item in plumbing_response.peering_groups: 4102 yield plumbing.convert_peering_group_to_porcelain( 4103 plumbing_item) 4104 if plumbing_response.meta.next_cursor == '': 4105 break 4106 req.meta.cursor = plumbing_response.meta.next_cursor 4107 4108 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
4111class Policies: 4112 ''' 4113 Policies are the collection of one or more statements that enforce fine-grained access 4114 control for the users of an organization. 4115 See `strongdm.models.Policy`. 4116 ''' 4117 def __init__(self, channel, client): 4118 self.parent = client 4119 self.stub = PoliciesStub(channel) 4120 4121 def create(self, policy, timeout=None): 4122 ''' 4123 Create creates a new Policy. 4124 ''' 4125 deadline = None if timeout is None else time.time() + timeout 4126 req = PolicyCreateRequest() 4127 4128 if policy is not None: 4129 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4130 tries = 0 4131 plumbing_response = None 4132 while True: 4133 t = None if deadline is None else deadline - time.time() 4134 try: 4135 plumbing_response = self.stub.Create( 4136 req, 4137 metadata=self.parent.get_metadata('Policies.Create', req), 4138 timeout=t) 4139 except Exception as e: 4140 if self.parent.shouldRetry(tries, e, deadline): 4141 tries += 1 4142 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4143 continue 4144 raise plumbing.convert_error_to_porcelain(e) from e 4145 break 4146 4147 resp = models.PolicyCreateResponse() 4148 resp.policy = plumbing.convert_policy_to_porcelain( 4149 plumbing_response.policy) 4150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4151 plumbing_response.rate_limit) 4152 return resp 4153 4154 def delete(self, id, timeout=None): 4155 ''' 4156 Delete removes a Policy by ID. 4157 ''' 4158 deadline = None if timeout is None else time.time() + timeout 4159 req = PolicyDeleteRequest() 4160 4161 req.id = (id) 4162 tries = 0 4163 plumbing_response = None 4164 while True: 4165 t = None if deadline is None else deadline - time.time() 4166 try: 4167 plumbing_response = self.stub.Delete( 4168 req, 4169 metadata=self.parent.get_metadata('Policies.Delete', req), 4170 timeout=t) 4171 except Exception as e: 4172 if self.parent.shouldRetry(tries, e, deadline): 4173 tries += 1 4174 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4175 continue 4176 raise plumbing.convert_error_to_porcelain(e) from e 4177 break 4178 4179 resp = models.PolicyDeleteResponse() 4180 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4181 plumbing_response.rate_limit) 4182 return resp 4183 4184 def update(self, policy, timeout=None): 4185 ''' 4186 Update replaces all the fields of a Policy by ID. 4187 ''' 4188 deadline = None if timeout is None else time.time() + timeout 4189 req = PolicyUpdateRequest() 4190 4191 if policy is not None: 4192 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4193 tries = 0 4194 plumbing_response = None 4195 while True: 4196 t = None if deadline is None else deadline - time.time() 4197 try: 4198 plumbing_response = self.stub.Update( 4199 req, 4200 metadata=self.parent.get_metadata('Policies.Update', req), 4201 timeout=t) 4202 except Exception as e: 4203 if self.parent.shouldRetry(tries, e, deadline): 4204 tries += 1 4205 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4206 continue 4207 raise plumbing.convert_error_to_porcelain(e) from e 4208 break 4209 4210 resp = models.PolicyUpdateResponse() 4211 resp.policy = plumbing.convert_policy_to_porcelain( 4212 plumbing_response.policy) 4213 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4214 plumbing_response.rate_limit) 4215 return resp 4216 4217 def get(self, id, timeout=None): 4218 ''' 4219 Get reads one Policy by ID. 4220 ''' 4221 deadline = None if timeout is None else time.time() + timeout 4222 req = PolicyGetRequest() 4223 if self.parent.snapshot_datetime is not None: 4224 req.meta.CopyFrom(GetRequestMetadata()) 4225 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4226 4227 req.id = (id) 4228 tries = 0 4229 plumbing_response = None 4230 while True: 4231 t = None if deadline is None else deadline - time.time() 4232 try: 4233 plumbing_response = self.stub.Get( 4234 req, 4235 metadata=self.parent.get_metadata('Policies.Get', req), 4236 timeout=t) 4237 except Exception as e: 4238 if self.parent.shouldRetry(tries, e, deadline): 4239 tries += 1 4240 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4241 continue 4242 raise plumbing.convert_error_to_porcelain(e) from e 4243 break 4244 4245 resp = models.PolicyGetResponse() 4246 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4247 plumbing_response.meta) 4248 resp.policy = plumbing.convert_policy_to_porcelain( 4249 plumbing_response.policy) 4250 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4251 plumbing_response.rate_limit) 4252 return resp 4253 4254 def list(self, filter, *args, timeout=None): 4255 ''' 4256 List gets a list of Policy matching a given set of criteria 4257 ''' 4258 deadline = None if timeout is None else time.time() + timeout 4259 req = PolicyListRequest() 4260 req.meta.CopyFrom(ListRequestMetadata()) 4261 if self.parent.page_limit > 0: 4262 req.meta.limit = self.parent.page_limit 4263 if self.parent.snapshot_datetime is not None: 4264 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4265 4266 req.filter = plumbing.quote_filter_args(filter, *args) 4267 4268 def generator(svc, req): 4269 tries = 0 4270 while True: 4271 t = None if deadline is None else deadline - time.time() 4272 try: 4273 plumbing_response = svc.stub.List( 4274 req, 4275 metadata=svc.parent.get_metadata('Policies.List', req), 4276 timeout=t) 4277 except Exception as e: 4278 if self.parent.shouldRetry(tries, e, deadline): 4279 tries += 1 4280 time.sleep( 4281 self.parent.exponentialBackoff(tries, deadline)) 4282 continue 4283 raise plumbing.convert_error_to_porcelain(e) from e 4284 tries = 0 4285 for plumbing_item in plumbing_response.policies: 4286 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4287 if plumbing_response.meta.next_cursor == '': 4288 break 4289 req.meta.cursor = plumbing_response.meta.next_cursor 4290 4291 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)
4121 def create(self, policy, timeout=None): 4122 ''' 4123 Create creates a new Policy. 4124 ''' 4125 deadline = None if timeout is None else time.time() + timeout 4126 req = PolicyCreateRequest() 4127 4128 if policy is not None: 4129 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4130 tries = 0 4131 plumbing_response = None 4132 while True: 4133 t = None if deadline is None else deadline - time.time() 4134 try: 4135 plumbing_response = self.stub.Create( 4136 req, 4137 metadata=self.parent.get_metadata('Policies.Create', req), 4138 timeout=t) 4139 except Exception as e: 4140 if self.parent.shouldRetry(tries, e, deadline): 4141 tries += 1 4142 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4143 continue 4144 raise plumbing.convert_error_to_porcelain(e) from e 4145 break 4146 4147 resp = models.PolicyCreateResponse() 4148 resp.policy = plumbing.convert_policy_to_porcelain( 4149 plumbing_response.policy) 4150 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4151 plumbing_response.rate_limit) 4152 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
4154 def delete(self, id, timeout=None): 4155 ''' 4156 Delete removes a Policy by ID. 4157 ''' 4158 deadline = None if timeout is None else time.time() + timeout 4159 req = PolicyDeleteRequest() 4160 4161 req.id = (id) 4162 tries = 0 4163 plumbing_response = None 4164 while True: 4165 t = None if deadline is None else deadline - time.time() 4166 try: 4167 plumbing_response = self.stub.Delete( 4168 req, 4169 metadata=self.parent.get_metadata('Policies.Delete', req), 4170 timeout=t) 4171 except Exception as e: 4172 if self.parent.shouldRetry(tries, e, deadline): 4173 tries += 1 4174 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4175 continue 4176 raise plumbing.convert_error_to_porcelain(e) from e 4177 break 4178 4179 resp = models.PolicyDeleteResponse() 4180 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4181 plumbing_response.rate_limit) 4182 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
4184 def update(self, policy, timeout=None): 4185 ''' 4186 Update replaces all the fields of a Policy by ID. 4187 ''' 4188 deadline = None if timeout is None else time.time() + timeout 4189 req = PolicyUpdateRequest() 4190 4191 if policy is not None: 4192 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 4193 tries = 0 4194 plumbing_response = None 4195 while True: 4196 t = None if deadline is None else deadline - time.time() 4197 try: 4198 plumbing_response = self.stub.Update( 4199 req, 4200 metadata=self.parent.get_metadata('Policies.Update', req), 4201 timeout=t) 4202 except Exception as e: 4203 if self.parent.shouldRetry(tries, e, deadline): 4204 tries += 1 4205 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4206 continue 4207 raise plumbing.convert_error_to_porcelain(e) from e 4208 break 4209 4210 resp = models.PolicyUpdateResponse() 4211 resp.policy = plumbing.convert_policy_to_porcelain( 4212 plumbing_response.policy) 4213 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4214 plumbing_response.rate_limit) 4215 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
4217 def get(self, id, timeout=None): 4218 ''' 4219 Get reads one Policy by ID. 4220 ''' 4221 deadline = None if timeout is None else time.time() + timeout 4222 req = PolicyGetRequest() 4223 if self.parent.snapshot_datetime is not None: 4224 req.meta.CopyFrom(GetRequestMetadata()) 4225 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4226 4227 req.id = (id) 4228 tries = 0 4229 plumbing_response = None 4230 while True: 4231 t = None if deadline is None else deadline - time.time() 4232 try: 4233 plumbing_response = self.stub.Get( 4234 req, 4235 metadata=self.parent.get_metadata('Policies.Get', req), 4236 timeout=t) 4237 except Exception as e: 4238 if self.parent.shouldRetry(tries, e, deadline): 4239 tries += 1 4240 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4241 continue 4242 raise plumbing.convert_error_to_porcelain(e) from e 4243 break 4244 4245 resp = models.PolicyGetResponse() 4246 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4247 plumbing_response.meta) 4248 resp.policy = plumbing.convert_policy_to_porcelain( 4249 plumbing_response.policy) 4250 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4251 plumbing_response.rate_limit) 4252 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
4254 def list(self, filter, *args, timeout=None): 4255 ''' 4256 List gets a list of Policy matching a given set of criteria 4257 ''' 4258 deadline = None if timeout is None else time.time() + timeout 4259 req = PolicyListRequest() 4260 req.meta.CopyFrom(ListRequestMetadata()) 4261 if self.parent.page_limit > 0: 4262 req.meta.limit = self.parent.page_limit 4263 if self.parent.snapshot_datetime is not None: 4264 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4265 4266 req.filter = plumbing.quote_filter_args(filter, *args) 4267 4268 def generator(svc, req): 4269 tries = 0 4270 while True: 4271 t = None if deadline is None else deadline - time.time() 4272 try: 4273 plumbing_response = svc.stub.List( 4274 req, 4275 metadata=svc.parent.get_metadata('Policies.List', req), 4276 timeout=t) 4277 except Exception as e: 4278 if self.parent.shouldRetry(tries, e, deadline): 4279 tries += 1 4280 time.sleep( 4281 self.parent.exponentialBackoff(tries, deadline)) 4282 continue 4283 raise plumbing.convert_error_to_porcelain(e) from e 4284 tries = 0 4285 for plumbing_item in plumbing_response.policies: 4286 yield plumbing.convert_policy_to_porcelain(plumbing_item) 4287 if plumbing_response.meta.next_cursor == '': 4288 break 4289 req.meta.cursor = plumbing_response.meta.next_cursor 4290 4291 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
4294class SnapshotPolicies: 4295 ''' 4296 SnapshotPolicies exposes the read only methods of the Policies 4297 service for historical queries. 4298 ''' 4299 def __init__(self, policies): 4300 self.policies = policies 4301 4302 def get(self, id, timeout=None): 4303 ''' 4304 Get reads one Policy by ID. 4305 ''' 4306 return self.policies.get(id, timeout=timeout) 4307 4308 def list(self, filter, *args, timeout=None): 4309 ''' 4310 List gets a list of Policy matching a given set of criteria 4311 ''' 4312 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
4315class PoliciesHistory: 4316 ''' 4317 PoliciesHistory records all changes to the state of a Policy. 4318 See `strongdm.models.PolicyHistory`. 4319 ''' 4320 def __init__(self, channel, client): 4321 self.parent = client 4322 self.stub = PoliciesHistoryStub(channel) 4323 4324 def list(self, filter, *args, timeout=None): 4325 ''' 4326 List gets a list of PolicyHistory records matching a given set of criteria. 4327 ''' 4328 deadline = None if timeout is None else time.time() + timeout 4329 req = PoliciesHistoryListRequest() 4330 req.meta.CopyFrom(ListRequestMetadata()) 4331 if self.parent.page_limit > 0: 4332 req.meta.limit = self.parent.page_limit 4333 if self.parent.snapshot_datetime is not None: 4334 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4335 4336 req.filter = plumbing.quote_filter_args(filter, *args) 4337 4338 def generator(svc, req): 4339 tries = 0 4340 while True: 4341 t = None if deadline is None else deadline - time.time() 4342 try: 4343 plumbing_response = svc.stub.List( 4344 req, 4345 metadata=svc.parent.get_metadata( 4346 'PoliciesHistory.List', req), 4347 timeout=t) 4348 except Exception as e: 4349 if self.parent.shouldRetry(tries, e, deadline): 4350 tries += 1 4351 time.sleep( 4352 self.parent.exponentialBackoff(tries, deadline)) 4353 continue 4354 raise plumbing.convert_error_to_porcelain(e) from e 4355 tries = 0 4356 for plumbing_item in plumbing_response.history: 4357 yield plumbing.convert_policy_history_to_porcelain( 4358 plumbing_item) 4359 if plumbing_response.meta.next_cursor == '': 4360 break 4361 req.meta.cursor = plumbing_response.meta.next_cursor 4362 4363 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)
4324 def list(self, filter, *args, timeout=None): 4325 ''' 4326 List gets a list of PolicyHistory records matching a given set of criteria. 4327 ''' 4328 deadline = None if timeout is None else time.time() + timeout 4329 req = PoliciesHistoryListRequest() 4330 req.meta.CopyFrom(ListRequestMetadata()) 4331 if self.parent.page_limit > 0: 4332 req.meta.limit = self.parent.page_limit 4333 if self.parent.snapshot_datetime is not None: 4334 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4335 4336 req.filter = plumbing.quote_filter_args(filter, *args) 4337 4338 def generator(svc, req): 4339 tries = 0 4340 while True: 4341 t = None if deadline is None else deadline - time.time() 4342 try: 4343 plumbing_response = svc.stub.List( 4344 req, 4345 metadata=svc.parent.get_metadata( 4346 'PoliciesHistory.List', req), 4347 timeout=t) 4348 except Exception as e: 4349 if self.parent.shouldRetry(tries, e, deadline): 4350 tries += 1 4351 time.sleep( 4352 self.parent.exponentialBackoff(tries, deadline)) 4353 continue 4354 raise plumbing.convert_error_to_porcelain(e) from e 4355 tries = 0 4356 for plumbing_item in plumbing_response.history: 4357 yield plumbing.convert_policy_history_to_porcelain( 4358 plumbing_item) 4359 if plumbing_response.meta.next_cursor == '': 4360 break 4361 req.meta.cursor = plumbing_response.meta.next_cursor 4362 4363 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
4366class ProxyClusterKeys: 4367 ''' 4368 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 4369 The proxies within a cluster share the same key. One cluster can have 4370 multiple keys in order to facilitate key rotation. 4371 See `strongdm.models.ProxyClusterKey`. 4372 ''' 4373 def __init__(self, channel, client): 4374 self.parent = client 4375 self.stub = ProxyClusterKeysStub(channel) 4376 4377 def create(self, proxy_cluster_key, timeout=None): 4378 ''' 4379 Create registers a new ProxyClusterKey. 4380 ''' 4381 deadline = None if timeout is None else time.time() + timeout 4382 req = ProxyClusterKeyCreateRequest() 4383 4384 if proxy_cluster_key is not None: 4385 req.proxy_cluster_key.CopyFrom( 4386 plumbing.convert_proxy_cluster_key_to_plumbing( 4387 proxy_cluster_key)) 4388 tries = 0 4389 plumbing_response = None 4390 while True: 4391 t = None if deadline is None else deadline - time.time() 4392 try: 4393 plumbing_response = self.stub.Create( 4394 req, 4395 metadata=self.parent.get_metadata( 4396 'ProxyClusterKeys.Create', req), 4397 timeout=t) 4398 except Exception as e: 4399 if self.parent.shouldRetry(tries, e, deadline): 4400 tries += 1 4401 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4402 continue 4403 raise plumbing.convert_error_to_porcelain(e) from e 4404 break 4405 4406 resp = models.ProxyClusterKeyCreateResponse() 4407 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4408 plumbing_response.meta) 4409 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4410 plumbing_response.proxy_cluster_key) 4411 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4412 plumbing_response.rate_limit) 4413 resp.secret_key = (plumbing_response.secret_key) 4414 return resp 4415 4416 def get(self, id, timeout=None): 4417 ''' 4418 Get reads one ProxyClusterKey by ID. 4419 ''' 4420 deadline = None if timeout is None else time.time() + timeout 4421 req = ProxyClusterKeyGetRequest() 4422 if self.parent.snapshot_datetime is not None: 4423 req.meta.CopyFrom(GetRequestMetadata()) 4424 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4425 4426 req.id = (id) 4427 tries = 0 4428 plumbing_response = None 4429 while True: 4430 t = None if deadline is None else deadline - time.time() 4431 try: 4432 plumbing_response = self.stub.Get( 4433 req, 4434 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4435 req), 4436 timeout=t) 4437 except Exception as e: 4438 if self.parent.shouldRetry(tries, e, deadline): 4439 tries += 1 4440 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4441 continue 4442 raise plumbing.convert_error_to_porcelain(e) from e 4443 break 4444 4445 resp = models.ProxyClusterKeyGetResponse() 4446 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4447 plumbing_response.meta) 4448 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4449 plumbing_response.proxy_cluster_key) 4450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4451 plumbing_response.rate_limit) 4452 return resp 4453 4454 def delete(self, id, timeout=None): 4455 ''' 4456 Delete removes a ProxyClusterKey by ID. 4457 ''' 4458 deadline = None if timeout is None else time.time() + timeout 4459 req = ProxyClusterKeyDeleteRequest() 4460 4461 req.id = (id) 4462 tries = 0 4463 plumbing_response = None 4464 while True: 4465 t = None if deadline is None else deadline - time.time() 4466 try: 4467 plumbing_response = self.stub.Delete( 4468 req, 4469 metadata=self.parent.get_metadata( 4470 'ProxyClusterKeys.Delete', req), 4471 timeout=t) 4472 except Exception as e: 4473 if self.parent.shouldRetry(tries, e, deadline): 4474 tries += 1 4475 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4476 continue 4477 raise plumbing.convert_error_to_porcelain(e) from e 4478 break 4479 4480 resp = models.ProxyClusterKeyDeleteResponse() 4481 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4482 plumbing_response.meta) 4483 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4484 plumbing_response.rate_limit) 4485 return resp 4486 4487 def list(self, filter, *args, timeout=None): 4488 ''' 4489 List gets a list of ProxyClusterKeys matching a given set of criteria. 4490 ''' 4491 deadline = None if timeout is None else time.time() + timeout 4492 req = ProxyClusterKeyListRequest() 4493 req.meta.CopyFrom(ListRequestMetadata()) 4494 if self.parent.page_limit > 0: 4495 req.meta.limit = self.parent.page_limit 4496 if self.parent.snapshot_datetime is not None: 4497 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4498 4499 req.filter = plumbing.quote_filter_args(filter, *args) 4500 4501 def generator(svc, req): 4502 tries = 0 4503 while True: 4504 t = None if deadline is None else deadline - time.time() 4505 try: 4506 plumbing_response = svc.stub.List( 4507 req, 4508 metadata=svc.parent.get_metadata( 4509 'ProxyClusterKeys.List', req), 4510 timeout=t) 4511 except Exception as e: 4512 if self.parent.shouldRetry(tries, e, deadline): 4513 tries += 1 4514 time.sleep( 4515 self.parent.exponentialBackoff(tries, deadline)) 4516 continue 4517 raise plumbing.convert_error_to_porcelain(e) from e 4518 tries = 0 4519 for plumbing_item in plumbing_response.proxy_cluster_keys: 4520 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4521 plumbing_item) 4522 if plumbing_response.meta.next_cursor == '': 4523 break 4524 req.meta.cursor = plumbing_response.meta.next_cursor 4525 4526 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)
4377 def create(self, proxy_cluster_key, timeout=None): 4378 ''' 4379 Create registers a new ProxyClusterKey. 4380 ''' 4381 deadline = None if timeout is None else time.time() + timeout 4382 req = ProxyClusterKeyCreateRequest() 4383 4384 if proxy_cluster_key is not None: 4385 req.proxy_cluster_key.CopyFrom( 4386 plumbing.convert_proxy_cluster_key_to_plumbing( 4387 proxy_cluster_key)) 4388 tries = 0 4389 plumbing_response = None 4390 while True: 4391 t = None if deadline is None else deadline - time.time() 4392 try: 4393 plumbing_response = self.stub.Create( 4394 req, 4395 metadata=self.parent.get_metadata( 4396 'ProxyClusterKeys.Create', req), 4397 timeout=t) 4398 except Exception as e: 4399 if self.parent.shouldRetry(tries, e, deadline): 4400 tries += 1 4401 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4402 continue 4403 raise plumbing.convert_error_to_porcelain(e) from e 4404 break 4405 4406 resp = models.ProxyClusterKeyCreateResponse() 4407 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4408 plumbing_response.meta) 4409 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4410 plumbing_response.proxy_cluster_key) 4411 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4412 plumbing_response.rate_limit) 4413 resp.secret_key = (plumbing_response.secret_key) 4414 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
4416 def get(self, id, timeout=None): 4417 ''' 4418 Get reads one ProxyClusterKey by ID. 4419 ''' 4420 deadline = None if timeout is None else time.time() + timeout 4421 req = ProxyClusterKeyGetRequest() 4422 if self.parent.snapshot_datetime is not None: 4423 req.meta.CopyFrom(GetRequestMetadata()) 4424 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4425 4426 req.id = (id) 4427 tries = 0 4428 plumbing_response = None 4429 while True: 4430 t = None if deadline is None else deadline - time.time() 4431 try: 4432 plumbing_response = self.stub.Get( 4433 req, 4434 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 4435 req), 4436 timeout=t) 4437 except Exception as e: 4438 if self.parent.shouldRetry(tries, e, deadline): 4439 tries += 1 4440 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4441 continue 4442 raise plumbing.convert_error_to_porcelain(e) from e 4443 break 4444 4445 resp = models.ProxyClusterKeyGetResponse() 4446 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4447 plumbing_response.meta) 4448 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 4449 plumbing_response.proxy_cluster_key) 4450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4451 plumbing_response.rate_limit) 4452 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
4454 def delete(self, id, timeout=None): 4455 ''' 4456 Delete removes a ProxyClusterKey by ID. 4457 ''' 4458 deadline = None if timeout is None else time.time() + timeout 4459 req = ProxyClusterKeyDeleteRequest() 4460 4461 req.id = (id) 4462 tries = 0 4463 plumbing_response = None 4464 while True: 4465 t = None if deadline is None else deadline - time.time() 4466 try: 4467 plumbing_response = self.stub.Delete( 4468 req, 4469 metadata=self.parent.get_metadata( 4470 'ProxyClusterKeys.Delete', req), 4471 timeout=t) 4472 except Exception as e: 4473 if self.parent.shouldRetry(tries, e, deadline): 4474 tries += 1 4475 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4476 continue 4477 raise plumbing.convert_error_to_porcelain(e) from e 4478 break 4479 4480 resp = models.ProxyClusterKeyDeleteResponse() 4481 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4482 plumbing_response.meta) 4483 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4484 plumbing_response.rate_limit) 4485 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4487 def list(self, filter, *args, timeout=None): 4488 ''' 4489 List gets a list of ProxyClusterKeys matching a given set of criteria. 4490 ''' 4491 deadline = None if timeout is None else time.time() + timeout 4492 req = ProxyClusterKeyListRequest() 4493 req.meta.CopyFrom(ListRequestMetadata()) 4494 if self.parent.page_limit > 0: 4495 req.meta.limit = self.parent.page_limit 4496 if self.parent.snapshot_datetime is not None: 4497 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4498 4499 req.filter = plumbing.quote_filter_args(filter, *args) 4500 4501 def generator(svc, req): 4502 tries = 0 4503 while True: 4504 t = None if deadline is None else deadline - time.time() 4505 try: 4506 plumbing_response = svc.stub.List( 4507 req, 4508 metadata=svc.parent.get_metadata( 4509 'ProxyClusterKeys.List', req), 4510 timeout=t) 4511 except Exception as e: 4512 if self.parent.shouldRetry(tries, e, deadline): 4513 tries += 1 4514 time.sleep( 4515 self.parent.exponentialBackoff(tries, deadline)) 4516 continue 4517 raise plumbing.convert_error_to_porcelain(e) from e 4518 tries = 0 4519 for plumbing_item in plumbing_response.proxy_cluster_keys: 4520 yield plumbing.convert_proxy_cluster_key_to_porcelain( 4521 plumbing_item) 4522 if plumbing_response.meta.next_cursor == '': 4523 break 4524 req.meta.cursor = plumbing_response.meta.next_cursor 4525 4526 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
4529class SnapshotProxyClusterKeys: 4530 ''' 4531 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 4532 service for historical queries. 4533 ''' 4534 def __init__(self, proxy_cluster_keys): 4535 self.proxy_cluster_keys = proxy_cluster_keys 4536 4537 def get(self, id, timeout=None): 4538 ''' 4539 Get reads one ProxyClusterKey by ID. 4540 ''' 4541 return self.proxy_cluster_keys.get(id, timeout=timeout) 4542 4543 def list(self, filter, *args, timeout=None): 4544 ''' 4545 List gets a list of ProxyClusterKeys matching a given set of criteria. 4546 ''' 4547 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)
4537 def get(self, id, timeout=None): 4538 ''' 4539 Get reads one ProxyClusterKey by ID. 4540 ''' 4541 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
4543 def list(self, filter, *args, timeout=None): 4544 ''' 4545 List gets a list of ProxyClusterKeys matching a given set of criteria. 4546 ''' 4547 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
4550class Queries: 4551 ''' 4552 A Query is a record of a single client request to a resource, such as a SQL query. 4553 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 4554 The Queries service is read-only. 4555 See `strongdm.models.Query`. 4556 ''' 4557 def __init__(self, channel, client): 4558 self.parent = client 4559 self.stub = QueriesStub(channel) 4560 4561 def list(self, filter, *args, timeout=None): 4562 ''' 4563 List gets a list of Queries matching a given set of criteria. 4564 ''' 4565 deadline = None if timeout is None else time.time() + timeout 4566 req = QueryListRequest() 4567 req.meta.CopyFrom(ListRequestMetadata()) 4568 if self.parent.page_limit > 0: 4569 req.meta.limit = self.parent.page_limit 4570 if self.parent.snapshot_datetime is not None: 4571 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4572 4573 req.filter = plumbing.quote_filter_args(filter, *args) 4574 4575 def generator(svc, req): 4576 tries = 0 4577 while True: 4578 t = None if deadline is None else deadline - time.time() 4579 try: 4580 plumbing_response = svc.stub.List( 4581 req, 4582 metadata=svc.parent.get_metadata('Queries.List', req), 4583 timeout=t) 4584 except Exception as e: 4585 if self.parent.shouldRetry(tries, e, deadline): 4586 tries += 1 4587 time.sleep( 4588 self.parent.exponentialBackoff(tries, deadline)) 4589 continue 4590 raise plumbing.convert_error_to_porcelain(e) from e 4591 tries = 0 4592 for plumbing_item in plumbing_response.queries: 4593 yield plumbing.convert_query_to_porcelain(plumbing_item) 4594 if plumbing_response.meta.next_cursor == '': 4595 break 4596 req.meta.cursor = plumbing_response.meta.next_cursor 4597 4598 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)
4561 def list(self, filter, *args, timeout=None): 4562 ''' 4563 List gets a list of Queries matching a given set of criteria. 4564 ''' 4565 deadline = None if timeout is None else time.time() + timeout 4566 req = QueryListRequest() 4567 req.meta.CopyFrom(ListRequestMetadata()) 4568 if self.parent.page_limit > 0: 4569 req.meta.limit = self.parent.page_limit 4570 if self.parent.snapshot_datetime is not None: 4571 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4572 4573 req.filter = plumbing.quote_filter_args(filter, *args) 4574 4575 def generator(svc, req): 4576 tries = 0 4577 while True: 4578 t = None if deadline is None else deadline - time.time() 4579 try: 4580 plumbing_response = svc.stub.List( 4581 req, 4582 metadata=svc.parent.get_metadata('Queries.List', req), 4583 timeout=t) 4584 except Exception as e: 4585 if self.parent.shouldRetry(tries, e, deadline): 4586 tries += 1 4587 time.sleep( 4588 self.parent.exponentialBackoff(tries, deadline)) 4589 continue 4590 raise plumbing.convert_error_to_porcelain(e) from e 4591 tries = 0 4592 for plumbing_item in plumbing_response.queries: 4593 yield plumbing.convert_query_to_porcelain(plumbing_item) 4594 if plumbing_response.meta.next_cursor == '': 4595 break 4596 req.meta.cursor = plumbing_response.meta.next_cursor 4597 4598 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
4601class RemoteIdentities: 4602 ''' 4603 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 4604 See `strongdm.models.RemoteIdentity`. 4605 ''' 4606 def __init__(self, channel, client): 4607 self.parent = client 4608 self.stub = RemoteIdentitiesStub(channel) 4609 4610 def create(self, remote_identity, timeout=None): 4611 ''' 4612 Create registers a new RemoteIdentity. 4613 ''' 4614 deadline = None if timeout is None else time.time() + timeout 4615 req = RemoteIdentityCreateRequest() 4616 4617 if remote_identity is not None: 4618 req.remote_identity.CopyFrom( 4619 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4620 tries = 0 4621 plumbing_response = None 4622 while True: 4623 t = None if deadline is None else deadline - time.time() 4624 try: 4625 plumbing_response = self.stub.Create( 4626 req, 4627 metadata=self.parent.get_metadata( 4628 'RemoteIdentities.Create', req), 4629 timeout=t) 4630 except Exception as e: 4631 if self.parent.shouldRetry(tries, e, deadline): 4632 tries += 1 4633 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4634 continue 4635 raise plumbing.convert_error_to_porcelain(e) from e 4636 break 4637 4638 resp = models.RemoteIdentityCreateResponse() 4639 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4640 plumbing_response.meta) 4641 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4642 plumbing_response.rate_limit) 4643 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4644 plumbing_response.remote_identity) 4645 return resp 4646 4647 def get(self, id, timeout=None): 4648 ''' 4649 Get reads one RemoteIdentity by ID. 4650 ''' 4651 deadline = None if timeout is None else time.time() + timeout 4652 req = RemoteIdentityGetRequest() 4653 if self.parent.snapshot_datetime is not None: 4654 req.meta.CopyFrom(GetRequestMetadata()) 4655 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4656 4657 req.id = (id) 4658 tries = 0 4659 plumbing_response = None 4660 while True: 4661 t = None if deadline is None else deadline - time.time() 4662 try: 4663 plumbing_response = self.stub.Get( 4664 req, 4665 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4666 req), 4667 timeout=t) 4668 except Exception as e: 4669 if self.parent.shouldRetry(tries, e, deadline): 4670 tries += 1 4671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4672 continue 4673 raise plumbing.convert_error_to_porcelain(e) from e 4674 break 4675 4676 resp = models.RemoteIdentityGetResponse() 4677 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4678 plumbing_response.meta) 4679 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4680 plumbing_response.rate_limit) 4681 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4682 plumbing_response.remote_identity) 4683 return resp 4684 4685 def update(self, remote_identity, timeout=None): 4686 ''' 4687 Update replaces all the fields of a RemoteIdentity by ID. 4688 ''' 4689 deadline = None if timeout is None else time.time() + timeout 4690 req = RemoteIdentityUpdateRequest() 4691 4692 if remote_identity is not None: 4693 req.remote_identity.CopyFrom( 4694 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4695 tries = 0 4696 plumbing_response = None 4697 while True: 4698 t = None if deadline is None else deadline - time.time() 4699 try: 4700 plumbing_response = self.stub.Update( 4701 req, 4702 metadata=self.parent.get_metadata( 4703 'RemoteIdentities.Update', req), 4704 timeout=t) 4705 except Exception as e: 4706 if self.parent.shouldRetry(tries, e, deadline): 4707 tries += 1 4708 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4709 continue 4710 raise plumbing.convert_error_to_porcelain(e) from e 4711 break 4712 4713 resp = models.RemoteIdentityUpdateResponse() 4714 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4715 plumbing_response.meta) 4716 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4717 plumbing_response.rate_limit) 4718 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4719 plumbing_response.remote_identity) 4720 return resp 4721 4722 def delete(self, id, timeout=None): 4723 ''' 4724 Delete removes a RemoteIdentity by ID. 4725 ''' 4726 deadline = None if timeout is None else time.time() + timeout 4727 req = RemoteIdentityDeleteRequest() 4728 4729 req.id = (id) 4730 tries = 0 4731 plumbing_response = None 4732 while True: 4733 t = None if deadline is None else deadline - time.time() 4734 try: 4735 plumbing_response = self.stub.Delete( 4736 req, 4737 metadata=self.parent.get_metadata( 4738 'RemoteIdentities.Delete', req), 4739 timeout=t) 4740 except Exception as e: 4741 if self.parent.shouldRetry(tries, e, deadline): 4742 tries += 1 4743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4744 continue 4745 raise plumbing.convert_error_to_porcelain(e) from e 4746 break 4747 4748 resp = models.RemoteIdentityDeleteResponse() 4749 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4750 plumbing_response.meta) 4751 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4752 plumbing_response.rate_limit) 4753 return resp 4754 4755 def list(self, filter, *args, timeout=None): 4756 ''' 4757 List gets a list of RemoteIdentities matching a given set of criteria. 4758 ''' 4759 deadline = None if timeout is None else time.time() + timeout 4760 req = RemoteIdentityListRequest() 4761 req.meta.CopyFrom(ListRequestMetadata()) 4762 if self.parent.page_limit > 0: 4763 req.meta.limit = self.parent.page_limit 4764 if self.parent.snapshot_datetime is not None: 4765 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4766 4767 req.filter = plumbing.quote_filter_args(filter, *args) 4768 4769 def generator(svc, req): 4770 tries = 0 4771 while True: 4772 t = None if deadline is None else deadline - time.time() 4773 try: 4774 plumbing_response = svc.stub.List( 4775 req, 4776 metadata=svc.parent.get_metadata( 4777 'RemoteIdentities.List', req), 4778 timeout=t) 4779 except Exception as e: 4780 if self.parent.shouldRetry(tries, e, deadline): 4781 tries += 1 4782 time.sleep( 4783 self.parent.exponentialBackoff(tries, deadline)) 4784 continue 4785 raise plumbing.convert_error_to_porcelain(e) from e 4786 tries = 0 4787 for plumbing_item in plumbing_response.remote_identities: 4788 yield plumbing.convert_remote_identity_to_porcelain( 4789 plumbing_item) 4790 if plumbing_response.meta.next_cursor == '': 4791 break 4792 req.meta.cursor = plumbing_response.meta.next_cursor 4793 4794 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)
4610 def create(self, remote_identity, timeout=None): 4611 ''' 4612 Create registers a new RemoteIdentity. 4613 ''' 4614 deadline = None if timeout is None else time.time() + timeout 4615 req = RemoteIdentityCreateRequest() 4616 4617 if remote_identity is not None: 4618 req.remote_identity.CopyFrom( 4619 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4620 tries = 0 4621 plumbing_response = None 4622 while True: 4623 t = None if deadline is None else deadline - time.time() 4624 try: 4625 plumbing_response = self.stub.Create( 4626 req, 4627 metadata=self.parent.get_metadata( 4628 'RemoteIdentities.Create', req), 4629 timeout=t) 4630 except Exception as e: 4631 if self.parent.shouldRetry(tries, e, deadline): 4632 tries += 1 4633 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4634 continue 4635 raise plumbing.convert_error_to_porcelain(e) from e 4636 break 4637 4638 resp = models.RemoteIdentityCreateResponse() 4639 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4640 plumbing_response.meta) 4641 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4642 plumbing_response.rate_limit) 4643 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4644 plumbing_response.remote_identity) 4645 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
4647 def get(self, id, timeout=None): 4648 ''' 4649 Get reads one RemoteIdentity by ID. 4650 ''' 4651 deadline = None if timeout is None else time.time() + timeout 4652 req = RemoteIdentityGetRequest() 4653 if self.parent.snapshot_datetime is not None: 4654 req.meta.CopyFrom(GetRequestMetadata()) 4655 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4656 4657 req.id = (id) 4658 tries = 0 4659 plumbing_response = None 4660 while True: 4661 t = None if deadline is None else deadline - time.time() 4662 try: 4663 plumbing_response = self.stub.Get( 4664 req, 4665 metadata=self.parent.get_metadata('RemoteIdentities.Get', 4666 req), 4667 timeout=t) 4668 except Exception as e: 4669 if self.parent.shouldRetry(tries, e, deadline): 4670 tries += 1 4671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4672 continue 4673 raise plumbing.convert_error_to_porcelain(e) from e 4674 break 4675 4676 resp = models.RemoteIdentityGetResponse() 4677 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4678 plumbing_response.meta) 4679 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4680 plumbing_response.rate_limit) 4681 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4682 plumbing_response.remote_identity) 4683 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
4685 def update(self, remote_identity, timeout=None): 4686 ''' 4687 Update replaces all the fields of a RemoteIdentity by ID. 4688 ''' 4689 deadline = None if timeout is None else time.time() + timeout 4690 req = RemoteIdentityUpdateRequest() 4691 4692 if remote_identity is not None: 4693 req.remote_identity.CopyFrom( 4694 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 4695 tries = 0 4696 plumbing_response = None 4697 while True: 4698 t = None if deadline is None else deadline - time.time() 4699 try: 4700 plumbing_response = self.stub.Update( 4701 req, 4702 metadata=self.parent.get_metadata( 4703 'RemoteIdentities.Update', req), 4704 timeout=t) 4705 except Exception as e: 4706 if self.parent.shouldRetry(tries, e, deadline): 4707 tries += 1 4708 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4709 continue 4710 raise plumbing.convert_error_to_porcelain(e) from e 4711 break 4712 4713 resp = models.RemoteIdentityUpdateResponse() 4714 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4715 plumbing_response.meta) 4716 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4717 plumbing_response.rate_limit) 4718 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 4719 plumbing_response.remote_identity) 4720 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
4722 def delete(self, id, timeout=None): 4723 ''' 4724 Delete removes a RemoteIdentity by ID. 4725 ''' 4726 deadline = None if timeout is None else time.time() + timeout 4727 req = RemoteIdentityDeleteRequest() 4728 4729 req.id = (id) 4730 tries = 0 4731 plumbing_response = None 4732 while True: 4733 t = None if deadline is None else deadline - time.time() 4734 try: 4735 plumbing_response = self.stub.Delete( 4736 req, 4737 metadata=self.parent.get_metadata( 4738 'RemoteIdentities.Delete', req), 4739 timeout=t) 4740 except Exception as e: 4741 if self.parent.shouldRetry(tries, e, deadline): 4742 tries += 1 4743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4744 continue 4745 raise plumbing.convert_error_to_porcelain(e) from e 4746 break 4747 4748 resp = models.RemoteIdentityDeleteResponse() 4749 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4750 plumbing_response.meta) 4751 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4752 plumbing_response.rate_limit) 4753 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
4755 def list(self, filter, *args, timeout=None): 4756 ''' 4757 List gets a list of RemoteIdentities matching a given set of criteria. 4758 ''' 4759 deadline = None if timeout is None else time.time() + timeout 4760 req = RemoteIdentityListRequest() 4761 req.meta.CopyFrom(ListRequestMetadata()) 4762 if self.parent.page_limit > 0: 4763 req.meta.limit = self.parent.page_limit 4764 if self.parent.snapshot_datetime is not None: 4765 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4766 4767 req.filter = plumbing.quote_filter_args(filter, *args) 4768 4769 def generator(svc, req): 4770 tries = 0 4771 while True: 4772 t = None if deadline is None else deadline - time.time() 4773 try: 4774 plumbing_response = svc.stub.List( 4775 req, 4776 metadata=svc.parent.get_metadata( 4777 'RemoteIdentities.List', req), 4778 timeout=t) 4779 except Exception as e: 4780 if self.parent.shouldRetry(tries, e, deadline): 4781 tries += 1 4782 time.sleep( 4783 self.parent.exponentialBackoff(tries, deadline)) 4784 continue 4785 raise plumbing.convert_error_to_porcelain(e) from e 4786 tries = 0 4787 for plumbing_item in plumbing_response.remote_identities: 4788 yield plumbing.convert_remote_identity_to_porcelain( 4789 plumbing_item) 4790 if plumbing_response.meta.next_cursor == '': 4791 break 4792 req.meta.cursor = plumbing_response.meta.next_cursor 4793 4794 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
4797class SnapshotRemoteIdentities: 4798 ''' 4799 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 4800 service for historical queries. 4801 ''' 4802 def __init__(self, remote_identities): 4803 self.remote_identities = remote_identities 4804 4805 def get(self, id, timeout=None): 4806 ''' 4807 Get reads one RemoteIdentity by ID. 4808 ''' 4809 return self.remote_identities.get(id, timeout=timeout) 4810 4811 def list(self, filter, *args, timeout=None): 4812 ''' 4813 List gets a list of RemoteIdentities matching a given set of criteria. 4814 ''' 4815 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)
4805 def get(self, id, timeout=None): 4806 ''' 4807 Get reads one RemoteIdentity by ID. 4808 ''' 4809 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
4811 def list(self, filter, *args, timeout=None): 4812 ''' 4813 List gets a list of RemoteIdentities matching a given set of criteria. 4814 ''' 4815 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
4818class RemoteIdentitiesHistory: 4819 ''' 4820 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 4821 See `strongdm.models.RemoteIdentityHistory`. 4822 ''' 4823 def __init__(self, channel, client): 4824 self.parent = client 4825 self.stub = RemoteIdentitiesHistoryStub(channel) 4826 4827 def list(self, filter, *args, timeout=None): 4828 ''' 4829 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4830 ''' 4831 deadline = None if timeout is None else time.time() + timeout 4832 req = RemoteIdentityHistoryListRequest() 4833 req.meta.CopyFrom(ListRequestMetadata()) 4834 if self.parent.page_limit > 0: 4835 req.meta.limit = self.parent.page_limit 4836 if self.parent.snapshot_datetime is not None: 4837 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4838 4839 req.filter = plumbing.quote_filter_args(filter, *args) 4840 4841 def generator(svc, req): 4842 tries = 0 4843 while True: 4844 t = None if deadline is None else deadline - time.time() 4845 try: 4846 plumbing_response = svc.stub.List( 4847 req, 4848 metadata=svc.parent.get_metadata( 4849 'RemoteIdentitiesHistory.List', req), 4850 timeout=t) 4851 except Exception as e: 4852 if self.parent.shouldRetry(tries, e, deadline): 4853 tries += 1 4854 time.sleep( 4855 self.parent.exponentialBackoff(tries, deadline)) 4856 continue 4857 raise plumbing.convert_error_to_porcelain(e) from e 4858 tries = 0 4859 for plumbing_item in plumbing_response.history: 4860 yield plumbing.convert_remote_identity_history_to_porcelain( 4861 plumbing_item) 4862 if plumbing_response.meta.next_cursor == '': 4863 break 4864 req.meta.cursor = plumbing_response.meta.next_cursor 4865 4866 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)
4827 def list(self, filter, *args, timeout=None): 4828 ''' 4829 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 4830 ''' 4831 deadline = None if timeout is None else time.time() + timeout 4832 req = RemoteIdentityHistoryListRequest() 4833 req.meta.CopyFrom(ListRequestMetadata()) 4834 if self.parent.page_limit > 0: 4835 req.meta.limit = self.parent.page_limit 4836 if self.parent.snapshot_datetime is not None: 4837 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4838 4839 req.filter = plumbing.quote_filter_args(filter, *args) 4840 4841 def generator(svc, req): 4842 tries = 0 4843 while True: 4844 t = None if deadline is None else deadline - time.time() 4845 try: 4846 plumbing_response = svc.stub.List( 4847 req, 4848 metadata=svc.parent.get_metadata( 4849 'RemoteIdentitiesHistory.List', req), 4850 timeout=t) 4851 except Exception as e: 4852 if self.parent.shouldRetry(tries, e, deadline): 4853 tries += 1 4854 time.sleep( 4855 self.parent.exponentialBackoff(tries, deadline)) 4856 continue 4857 raise plumbing.convert_error_to_porcelain(e) from e 4858 tries = 0 4859 for plumbing_item in plumbing_response.history: 4860 yield plumbing.convert_remote_identity_history_to_porcelain( 4861 plumbing_item) 4862 if plumbing_response.meta.next_cursor == '': 4863 break 4864 req.meta.cursor = plumbing_response.meta.next_cursor 4865 4866 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
4869class RemoteIdentityGroups: 4870 ''' 4871 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 4872 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 4873 See `strongdm.models.RemoteIdentityGroup`. 4874 ''' 4875 def __init__(self, channel, client): 4876 self.parent = client 4877 self.stub = RemoteIdentityGroupsStub(channel) 4878 4879 def get(self, id, timeout=None): 4880 ''' 4881 Get reads one RemoteIdentityGroup by ID. 4882 ''' 4883 deadline = None if timeout is None else time.time() + timeout 4884 req = RemoteIdentityGroupGetRequest() 4885 if self.parent.snapshot_datetime is not None: 4886 req.meta.CopyFrom(GetRequestMetadata()) 4887 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4888 4889 req.id = (id) 4890 tries = 0 4891 plumbing_response = None 4892 while True: 4893 t = None if deadline is None else deadline - time.time() 4894 try: 4895 plumbing_response = self.stub.Get( 4896 req, 4897 metadata=self.parent.get_metadata( 4898 'RemoteIdentityGroups.Get', req), 4899 timeout=t) 4900 except Exception as e: 4901 if self.parent.shouldRetry(tries, e, deadline): 4902 tries += 1 4903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4904 continue 4905 raise plumbing.convert_error_to_porcelain(e) from e 4906 break 4907 4908 resp = models.RemoteIdentityGroupGetResponse() 4909 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4910 plumbing_response.meta) 4911 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4912 plumbing_response.rate_limit) 4913 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4914 plumbing_response.remote_identity_group) 4915 return resp 4916 4917 def list(self, filter, *args, timeout=None): 4918 ''' 4919 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4920 ''' 4921 deadline = None if timeout is None else time.time() + timeout 4922 req = RemoteIdentityGroupListRequest() 4923 req.meta.CopyFrom(ListRequestMetadata()) 4924 if self.parent.page_limit > 0: 4925 req.meta.limit = self.parent.page_limit 4926 if self.parent.snapshot_datetime is not None: 4927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4928 4929 req.filter = plumbing.quote_filter_args(filter, *args) 4930 4931 def generator(svc, req): 4932 tries = 0 4933 while True: 4934 t = None if deadline is None else deadline - time.time() 4935 try: 4936 plumbing_response = svc.stub.List( 4937 req, 4938 metadata=svc.parent.get_metadata( 4939 'RemoteIdentityGroups.List', req), 4940 timeout=t) 4941 except Exception as e: 4942 if self.parent.shouldRetry(tries, e, deadline): 4943 tries += 1 4944 time.sleep( 4945 self.parent.exponentialBackoff(tries, deadline)) 4946 continue 4947 raise plumbing.convert_error_to_porcelain(e) from e 4948 tries = 0 4949 for plumbing_item in plumbing_response.remote_identity_groups: 4950 yield plumbing.convert_remote_identity_group_to_porcelain( 4951 plumbing_item) 4952 if plumbing_response.meta.next_cursor == '': 4953 break 4954 req.meta.cursor = plumbing_response.meta.next_cursor 4955 4956 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)
4879 def get(self, id, timeout=None): 4880 ''' 4881 Get reads one RemoteIdentityGroup by ID. 4882 ''' 4883 deadline = None if timeout is None else time.time() + timeout 4884 req = RemoteIdentityGroupGetRequest() 4885 if self.parent.snapshot_datetime is not None: 4886 req.meta.CopyFrom(GetRequestMetadata()) 4887 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4888 4889 req.id = (id) 4890 tries = 0 4891 plumbing_response = None 4892 while True: 4893 t = None if deadline is None else deadline - time.time() 4894 try: 4895 plumbing_response = self.stub.Get( 4896 req, 4897 metadata=self.parent.get_metadata( 4898 'RemoteIdentityGroups.Get', req), 4899 timeout=t) 4900 except Exception as e: 4901 if self.parent.shouldRetry(tries, e, deadline): 4902 tries += 1 4903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4904 continue 4905 raise plumbing.convert_error_to_porcelain(e) from e 4906 break 4907 4908 resp = models.RemoteIdentityGroupGetResponse() 4909 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4910 plumbing_response.meta) 4911 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4912 plumbing_response.rate_limit) 4913 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 4914 plumbing_response.remote_identity_group) 4915 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
4917 def list(self, filter, *args, timeout=None): 4918 ''' 4919 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4920 ''' 4921 deadline = None if timeout is None else time.time() + timeout 4922 req = RemoteIdentityGroupListRequest() 4923 req.meta.CopyFrom(ListRequestMetadata()) 4924 if self.parent.page_limit > 0: 4925 req.meta.limit = self.parent.page_limit 4926 if self.parent.snapshot_datetime is not None: 4927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4928 4929 req.filter = plumbing.quote_filter_args(filter, *args) 4930 4931 def generator(svc, req): 4932 tries = 0 4933 while True: 4934 t = None if deadline is None else deadline - time.time() 4935 try: 4936 plumbing_response = svc.stub.List( 4937 req, 4938 metadata=svc.parent.get_metadata( 4939 'RemoteIdentityGroups.List', req), 4940 timeout=t) 4941 except Exception as e: 4942 if self.parent.shouldRetry(tries, e, deadline): 4943 tries += 1 4944 time.sleep( 4945 self.parent.exponentialBackoff(tries, deadline)) 4946 continue 4947 raise plumbing.convert_error_to_porcelain(e) from e 4948 tries = 0 4949 for plumbing_item in plumbing_response.remote_identity_groups: 4950 yield plumbing.convert_remote_identity_group_to_porcelain( 4951 plumbing_item) 4952 if plumbing_response.meta.next_cursor == '': 4953 break 4954 req.meta.cursor = plumbing_response.meta.next_cursor 4955 4956 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
4959class SnapshotRemoteIdentityGroups: 4960 ''' 4961 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 4962 service for historical queries. 4963 ''' 4964 def __init__(self, remote_identity_groups): 4965 self.remote_identity_groups = remote_identity_groups 4966 4967 def get(self, id, timeout=None): 4968 ''' 4969 Get reads one RemoteIdentityGroup by ID. 4970 ''' 4971 return self.remote_identity_groups.get(id, timeout=timeout) 4972 4973 def list(self, filter, *args, timeout=None): 4974 ''' 4975 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4976 ''' 4977 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)
4967 def get(self, id, timeout=None): 4968 ''' 4969 Get reads one RemoteIdentityGroup by ID. 4970 ''' 4971 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
4973 def list(self, filter, *args, timeout=None): 4974 ''' 4975 List gets a list of RemoteIdentityGroups matching a given set of criteria. 4976 ''' 4977 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
4980class RemoteIdentityGroupsHistory: 4981 ''' 4982 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 4983 See `strongdm.models.RemoteIdentityGroupHistory`. 4984 ''' 4985 def __init__(self, channel, client): 4986 self.parent = client 4987 self.stub = RemoteIdentityGroupsHistoryStub(channel) 4988 4989 def list(self, filter, *args, timeout=None): 4990 ''' 4991 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4992 ''' 4993 deadline = None if timeout is None else time.time() + timeout 4994 req = RemoteIdentityGroupHistoryListRequest() 4995 req.meta.CopyFrom(ListRequestMetadata()) 4996 if self.parent.page_limit > 0: 4997 req.meta.limit = self.parent.page_limit 4998 if self.parent.snapshot_datetime is not None: 4999 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5000 5001 req.filter = plumbing.quote_filter_args(filter, *args) 5002 5003 def generator(svc, req): 5004 tries = 0 5005 while True: 5006 t = None if deadline is None else deadline - time.time() 5007 try: 5008 plumbing_response = svc.stub.List( 5009 req, 5010 metadata=svc.parent.get_metadata( 5011 'RemoteIdentityGroupsHistory.List', req), 5012 timeout=t) 5013 except Exception as e: 5014 if self.parent.shouldRetry(tries, e, deadline): 5015 tries += 1 5016 time.sleep( 5017 self.parent.exponentialBackoff(tries, deadline)) 5018 continue 5019 raise plumbing.convert_error_to_porcelain(e) from e 5020 tries = 0 5021 for plumbing_item in plumbing_response.history: 5022 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5023 plumbing_item) 5024 if plumbing_response.meta.next_cursor == '': 5025 break 5026 req.meta.cursor = plumbing_response.meta.next_cursor 5027 5028 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)
4989 def list(self, filter, *args, timeout=None): 4990 ''' 4991 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 4992 ''' 4993 deadline = None if timeout is None else time.time() + timeout 4994 req = RemoteIdentityGroupHistoryListRequest() 4995 req.meta.CopyFrom(ListRequestMetadata()) 4996 if self.parent.page_limit > 0: 4997 req.meta.limit = self.parent.page_limit 4998 if self.parent.snapshot_datetime is not None: 4999 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5000 5001 req.filter = plumbing.quote_filter_args(filter, *args) 5002 5003 def generator(svc, req): 5004 tries = 0 5005 while True: 5006 t = None if deadline is None else deadline - time.time() 5007 try: 5008 plumbing_response = svc.stub.List( 5009 req, 5010 metadata=svc.parent.get_metadata( 5011 'RemoteIdentityGroupsHistory.List', req), 5012 timeout=t) 5013 except Exception as e: 5014 if self.parent.shouldRetry(tries, e, deadline): 5015 tries += 1 5016 time.sleep( 5017 self.parent.exponentialBackoff(tries, deadline)) 5018 continue 5019 raise plumbing.convert_error_to_porcelain(e) from e 5020 tries = 0 5021 for plumbing_item in plumbing_response.history: 5022 yield plumbing.convert_remote_identity_group_history_to_porcelain( 5023 plumbing_item) 5024 if plumbing_response.meta.next_cursor == '': 5025 break 5026 req.meta.cursor = plumbing_response.meta.next_cursor 5027 5028 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
5031class Replays: 5032 ''' 5033 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 5034 (otherwise referred to as a query). The Replays service is read-only. 5035 See `strongdm.models.ReplayChunk`. 5036 ''' 5037 def __init__(self, channel, client): 5038 self.parent = client 5039 self.stub = ReplaysStub(channel) 5040 5041 def list(self, filter, *args, timeout=None): 5042 ''' 5043 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5044 ''' 5045 deadline = None if timeout is None else time.time() + timeout 5046 req = ReplayListRequest() 5047 req.meta.CopyFrom(ListRequestMetadata()) 5048 if self.parent.page_limit > 0: 5049 req.meta.limit = self.parent.page_limit 5050 if self.parent.snapshot_datetime is not None: 5051 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5052 5053 req.filter = plumbing.quote_filter_args(filter, *args) 5054 5055 def generator(svc, req): 5056 tries = 0 5057 while True: 5058 t = None if deadline is None else deadline - time.time() 5059 try: 5060 plumbing_response = svc.stub.List( 5061 req, 5062 metadata=svc.parent.get_metadata('Replays.List', req), 5063 timeout=t) 5064 except Exception as e: 5065 if self.parent.shouldRetry(tries, e, deadline): 5066 tries += 1 5067 time.sleep( 5068 self.parent.exponentialBackoff(tries, deadline)) 5069 continue 5070 raise plumbing.convert_error_to_porcelain(e) from e 5071 tries = 0 5072 for plumbing_item in plumbing_response.chunks: 5073 yield plumbing.convert_replay_chunk_to_porcelain( 5074 plumbing_item) 5075 if plumbing_response.meta.next_cursor == '': 5076 break 5077 req.meta.cursor = plumbing_response.meta.next_cursor 5078 5079 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)
5041 def list(self, filter, *args, timeout=None): 5042 ''' 5043 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 5044 ''' 5045 deadline = None if timeout is None else time.time() + timeout 5046 req = ReplayListRequest() 5047 req.meta.CopyFrom(ListRequestMetadata()) 5048 if self.parent.page_limit > 0: 5049 req.meta.limit = self.parent.page_limit 5050 if self.parent.snapshot_datetime is not None: 5051 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5052 5053 req.filter = plumbing.quote_filter_args(filter, *args) 5054 5055 def generator(svc, req): 5056 tries = 0 5057 while True: 5058 t = None if deadline is None else deadline - time.time() 5059 try: 5060 plumbing_response = svc.stub.List( 5061 req, 5062 metadata=svc.parent.get_metadata('Replays.List', req), 5063 timeout=t) 5064 except Exception as e: 5065 if self.parent.shouldRetry(tries, e, deadline): 5066 tries += 1 5067 time.sleep( 5068 self.parent.exponentialBackoff(tries, deadline)) 5069 continue 5070 raise plumbing.convert_error_to_porcelain(e) from e 5071 tries = 0 5072 for plumbing_item in plumbing_response.chunks: 5073 yield plumbing.convert_replay_chunk_to_porcelain( 5074 plumbing_item) 5075 if plumbing_response.meta.next_cursor == '': 5076 break 5077 req.meta.cursor = plumbing_response.meta.next_cursor 5078 5079 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
5082class Resources: 5083 ''' 5084 Resources are databases, servers, clusters, websites, or clouds that strongDM 5085 delegates access to. 5086 See: 5087 `strongdm.models.Aerospike` 5088 `strongdm.models.AKS` 5089 `strongdm.models.AKSBasicAuth` 5090 `strongdm.models.AKSServiceAccount` 5091 `strongdm.models.AKSServiceAccountUserImpersonation` 5092 `strongdm.models.AKSUserImpersonation` 5093 `strongdm.models.AmazonEKS` 5094 `strongdm.models.AmazonEKSInstanceProfile` 5095 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 5096 `strongdm.models.AmazonEKSUserImpersonation` 5097 `strongdm.models.AmazonES` 5098 `strongdm.models.AmazonESIAM` 5099 `strongdm.models.AmazonMQAMQP091` 5100 `strongdm.models.Athena` 5101 `strongdm.models.AthenaIAM` 5102 `strongdm.models.AuroraMysql` 5103 `strongdm.models.AuroraMysqlIAM` 5104 `strongdm.models.AuroraPostgres` 5105 `strongdm.models.AuroraPostgresIAM` 5106 `strongdm.models.AWS` 5107 `strongdm.models.AWSConsole` 5108 `strongdm.models.AWSConsoleStaticKeyPair` 5109 `strongdm.models.AWSInstanceProfile` 5110 `strongdm.models.Azure` 5111 `strongdm.models.AzureCertificate` 5112 `strongdm.models.AzureConsole` 5113 `strongdm.models.AzureMysql` 5114 `strongdm.models.AzurePostgres` 5115 `strongdm.models.AzurePostgresManagedIdentity` 5116 `strongdm.models.BigQuery` 5117 `strongdm.models.Cassandra` 5118 `strongdm.models.Citus` 5119 `strongdm.models.ClickHouseHTTP` 5120 `strongdm.models.ClickHouseMySQL` 5121 `strongdm.models.ClickHouseTCP` 5122 `strongdm.models.Clustrix` 5123 `strongdm.models.Cockroach` 5124 `strongdm.models.CouchbaseDatabase` 5125 `strongdm.models.CouchbaseWebUI` 5126 `strongdm.models.DB2I` 5127 `strongdm.models.DB2LUW` 5128 `strongdm.models.DocumentDBHost` 5129 `strongdm.models.DocumentDBHostIAM` 5130 `strongdm.models.DocumentDBReplicaSet` 5131 `strongdm.models.DocumentDBReplicaSetIAM` 5132 `strongdm.models.Druid` 5133 `strongdm.models.DynamoDB` 5134 `strongdm.models.DynamoDBIAM` 5135 `strongdm.models.Elastic` 5136 `strongdm.models.ElasticacheRedis` 5137 `strongdm.models.GCP` 5138 `strongdm.models.GCPConsole` 5139 `strongdm.models.GCPWIF` 5140 `strongdm.models.GoogleGKE` 5141 `strongdm.models.GoogleGKEUserImpersonation` 5142 `strongdm.models.Greenplum` 5143 `strongdm.models.HTTPAuth` 5144 `strongdm.models.HTTPBasicAuth` 5145 `strongdm.models.HTTPNoAuth` 5146 `strongdm.models.Kubernetes` 5147 `strongdm.models.KubernetesBasicAuth` 5148 `strongdm.models.KubernetesPodIdentity` 5149 `strongdm.models.KubernetesServiceAccount` 5150 `strongdm.models.KubernetesServiceAccountUserImpersonation` 5151 `strongdm.models.KubernetesUserImpersonation` 5152 `strongdm.models.Maria` 5153 `strongdm.models.Memcached` 5154 `strongdm.models.Memsql` 5155 `strongdm.models.MongoHost` 5156 `strongdm.models.MongoLegacyHost` 5157 `strongdm.models.MongoLegacyReplicaset` 5158 `strongdm.models.MongoReplicaSet` 5159 `strongdm.models.MongoShardedCluster` 5160 `strongdm.models.MTLSMysql` 5161 `strongdm.models.MTLSPostgres` 5162 `strongdm.models.Mysql` 5163 `strongdm.models.Neptune` 5164 `strongdm.models.NeptuneIAM` 5165 `strongdm.models.Oracle` 5166 `strongdm.models.OracleNNE` 5167 `strongdm.models.Postgres` 5168 `strongdm.models.Presto` 5169 `strongdm.models.RabbitMQAMQP091` 5170 `strongdm.models.RawTCP` 5171 `strongdm.models.RDP` 5172 `strongdm.models.RDPCert` 5173 `strongdm.models.RDSPostgresIAM` 5174 `strongdm.models.Redis` 5175 `strongdm.models.RedisCluster` 5176 `strongdm.models.Redshift` 5177 `strongdm.models.RedshiftIAM` 5178 `strongdm.models.RedshiftServerlessIAM` 5179 `strongdm.models.SingleStore` 5180 `strongdm.models.Snowflake` 5181 `strongdm.models.Snowsight` 5182 `strongdm.models.SQLServer` 5183 `strongdm.models.SQLServerAzureAD` 5184 `strongdm.models.SQLServerKerberosAD` 5185 `strongdm.models.SSH` 5186 `strongdm.models.SSHCert` 5187 `strongdm.models.SSHCustomerKey` 5188 `strongdm.models.SSHPassword` 5189 `strongdm.models.Sybase` 5190 `strongdm.models.SybaseIQ` 5191 `strongdm.models.Teradata` 5192 `strongdm.models.Trino` 5193 `strongdm.models.Vertica` 5194 ''' 5195 def __init__(self, channel, client): 5196 self.parent = client 5197 self.stub = ResourcesStub(channel) 5198 5199 def enumerate_tags(self, filter, *args, timeout=None): 5200 ''' 5201 EnumerateTags gets a list of the filter matching tags. 5202 ''' 5203 deadline = None if timeout is None else time.time() + timeout 5204 req = EnumerateTagsRequest() 5205 req.meta.CopyFrom(ListRequestMetadata()) 5206 if self.parent.page_limit > 0: 5207 req.meta.limit = self.parent.page_limit 5208 if self.parent.snapshot_datetime is not None: 5209 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5210 5211 req.filter = plumbing.quote_filter_args(filter, *args) 5212 5213 def generator(svc, req): 5214 tries = 0 5215 while True: 5216 t = None if deadline is None else deadline - time.time() 5217 try: 5218 plumbing_response = svc.stub.EnumerateTags( 5219 req, 5220 metadata=svc.parent.get_metadata( 5221 'Resources.EnumerateTags', req), 5222 timeout=t) 5223 except Exception as e: 5224 if self.parent.shouldRetry(tries, e, deadline): 5225 tries += 1 5226 time.sleep( 5227 self.parent.exponentialBackoff(tries, deadline)) 5228 continue 5229 raise plumbing.convert_error_to_porcelain(e) from e 5230 tries = 0 5231 for plumbing_item in plumbing_response.matches: 5232 yield plumbing.convert_tag_to_porcelain(plumbing_item) 5233 if plumbing_response.meta.next_cursor == '': 5234 break 5235 req.meta.cursor = plumbing_response.meta.next_cursor 5236 5237 return generator(self, req) 5238 5239 def create(self, resource, timeout=None): 5240 ''' 5241 Create registers a new Resource. 5242 ''' 5243 deadline = None if timeout is None else time.time() + timeout 5244 req = ResourceCreateRequest() 5245 5246 if resource is not None: 5247 req.resource.CopyFrom( 5248 plumbing.convert_resource_to_plumbing(resource)) 5249 tries = 0 5250 plumbing_response = None 5251 while True: 5252 t = None if deadline is None else deadline - time.time() 5253 try: 5254 plumbing_response = self.stub.Create( 5255 req, 5256 metadata=self.parent.get_metadata('Resources.Create', req), 5257 timeout=t) 5258 except Exception as e: 5259 if self.parent.shouldRetry(tries, e, deadline): 5260 tries += 1 5261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5262 continue 5263 raise plumbing.convert_error_to_porcelain(e) from e 5264 break 5265 5266 resp = models.ResourceCreateResponse() 5267 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5268 plumbing_response.meta) 5269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5270 plumbing_response.rate_limit) 5271 resp.resource = plumbing.convert_resource_to_porcelain( 5272 plumbing_response.resource) 5273 return resp 5274 5275 def get(self, id, timeout=None): 5276 ''' 5277 Get reads one Resource by ID. 5278 ''' 5279 deadline = None if timeout is None else time.time() + timeout 5280 req = ResourceGetRequest() 5281 if self.parent.snapshot_datetime is not None: 5282 req.meta.CopyFrom(GetRequestMetadata()) 5283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5284 5285 req.id = (id) 5286 tries = 0 5287 plumbing_response = None 5288 while True: 5289 t = None if deadline is None else deadline - time.time() 5290 try: 5291 plumbing_response = self.stub.Get( 5292 req, 5293 metadata=self.parent.get_metadata('Resources.Get', req), 5294 timeout=t) 5295 except Exception as e: 5296 if self.parent.shouldRetry(tries, e, deadline): 5297 tries += 1 5298 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5299 continue 5300 raise plumbing.convert_error_to_porcelain(e) from e 5301 break 5302 5303 resp = models.ResourceGetResponse() 5304 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5305 plumbing_response.meta) 5306 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5307 plumbing_response.rate_limit) 5308 resp.resource = plumbing.convert_resource_to_porcelain( 5309 plumbing_response.resource) 5310 return resp 5311 5312 def update(self, resource, timeout=None): 5313 ''' 5314 Update replaces all the fields of a Resource by ID. 5315 ''' 5316 deadline = None if timeout is None else time.time() + timeout 5317 req = ResourceUpdateRequest() 5318 5319 if resource is not None: 5320 req.resource.CopyFrom( 5321 plumbing.convert_resource_to_plumbing(resource)) 5322 tries = 0 5323 plumbing_response = None 5324 while True: 5325 t = None if deadline is None else deadline - time.time() 5326 try: 5327 plumbing_response = self.stub.Update( 5328 req, 5329 metadata=self.parent.get_metadata('Resources.Update', req), 5330 timeout=t) 5331 except Exception as e: 5332 if self.parent.shouldRetry(tries, e, deadline): 5333 tries += 1 5334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5335 continue 5336 raise plumbing.convert_error_to_porcelain(e) from e 5337 break 5338 5339 resp = models.ResourceUpdateResponse() 5340 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5341 plumbing_response.meta) 5342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5343 plumbing_response.rate_limit) 5344 resp.resource = plumbing.convert_resource_to_porcelain( 5345 plumbing_response.resource) 5346 return resp 5347 5348 def delete(self, id, timeout=None): 5349 ''' 5350 Delete removes a Resource by ID. 5351 ''' 5352 deadline = None if timeout is None else time.time() + timeout 5353 req = ResourceDeleteRequest() 5354 5355 req.id = (id) 5356 tries = 0 5357 plumbing_response = None 5358 while True: 5359 t = None if deadline is None else deadline - time.time() 5360 try: 5361 plumbing_response = self.stub.Delete( 5362 req, 5363 metadata=self.parent.get_metadata('Resources.Delete', req), 5364 timeout=t) 5365 except Exception as e: 5366 if self.parent.shouldRetry(tries, e, deadline): 5367 tries += 1 5368 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5369 continue 5370 raise plumbing.convert_error_to_porcelain(e) from e 5371 break 5372 5373 resp = models.ResourceDeleteResponse() 5374 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5375 plumbing_response.meta) 5376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5377 plumbing_response.rate_limit) 5378 return resp 5379 5380 def list(self, filter, *args, timeout=None): 5381 ''' 5382 List gets a list of Resources matching a given set of criteria. 5383 ''' 5384 deadline = None if timeout is None else time.time() + timeout 5385 req = ResourceListRequest() 5386 req.meta.CopyFrom(ListRequestMetadata()) 5387 if self.parent.page_limit > 0: 5388 req.meta.limit = self.parent.page_limit 5389 if self.parent.snapshot_datetime is not None: 5390 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5391 5392 req.filter = plumbing.quote_filter_args(filter, *args) 5393 5394 def generator(svc, req): 5395 tries = 0 5396 while True: 5397 t = None if deadline is None else deadline - time.time() 5398 try: 5399 plumbing_response = svc.stub.List( 5400 req, 5401 metadata=svc.parent.get_metadata( 5402 'Resources.List', req), 5403 timeout=t) 5404 except Exception as e: 5405 if self.parent.shouldRetry(tries, e, deadline): 5406 tries += 1 5407 time.sleep( 5408 self.parent.exponentialBackoff(tries, deadline)) 5409 continue 5410 raise plumbing.convert_error_to_porcelain(e) from e 5411 tries = 0 5412 for plumbing_item in plumbing_response.resources: 5413 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5414 if plumbing_response.meta.next_cursor == '': 5415 break 5416 req.meta.cursor = plumbing_response.meta.next_cursor 5417 5418 return generator(self, req) 5419 5420 def healthcheck(self, id, timeout=None): 5421 ''' 5422 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5423 large network of Nodes. The call will return immediately, and the updated health of the 5424 Resource can be retrieved via Get or List. 5425 ''' 5426 deadline = None if timeout is None else time.time() + timeout 5427 req = ResourceHealthcheckRequest() 5428 5429 req.id = (id) 5430 tries = 0 5431 plumbing_response = None 5432 while True: 5433 t = None if deadline is None else deadline - time.time() 5434 try: 5435 plumbing_response = self.stub.Healthcheck( 5436 req, 5437 metadata=self.parent.get_metadata('Resources.Healthcheck', 5438 req), 5439 timeout=t) 5440 except Exception as e: 5441 if self.parent.shouldRetry(tries, e, deadline): 5442 tries += 1 5443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5444 continue 5445 raise plumbing.convert_error_to_porcelain(e) from e 5446 break 5447 5448 resp = models.ResourceHealthcheckResponse() 5449 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5450 plumbing_response.meta) 5451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5452 plumbing_response.rate_limit) 5453 return resp
Resources are databases, servers, clusters, websites, or clouds that strongDM
delegates access to.
See:
strongdm.models.Aerospike
strongdm.models.AKS
strongdm.models.AKSBasicAuth
strongdm.models.AKSServiceAccount
strongdm.models.AKSServiceAccountUserImpersonation
strongdm.models.AKSUserImpersonation
strongdm.models.AmazonEKS
strongdm.models.AmazonEKSInstanceProfile
strongdm.models.AmazonEKSInstanceProfileUserImpersonation
strongdm.models.AmazonEKSUserImpersonation
strongdm.models.AmazonES
strongdm.models.AmazonESIAM
strongdm.models.AmazonMQAMQP091
strongdm.models.Athena
strongdm.models.AthenaIAM
strongdm.models.AuroraMysql
strongdm.models.AuroraMysqlIAM
strongdm.models.AuroraPostgres
strongdm.models.AuroraPostgresIAM
strongdm.models.AWS
strongdm.models.AWSConsole
strongdm.models.AWSConsoleStaticKeyPair
strongdm.models.AWSInstanceProfile
strongdm.models.Azure
strongdm.models.AzureCertificate
strongdm.models.AzureConsole
strongdm.models.AzureMysql
strongdm.models.AzurePostgres
strongdm.models.AzurePostgresManagedIdentity
strongdm.models.BigQuery
strongdm.models.Cassandra
strongdm.models.Citus
strongdm.models.ClickHouseHTTP
strongdm.models.ClickHouseMySQL
strongdm.models.ClickHouseTCP
strongdm.models.Clustrix
strongdm.models.Cockroach
strongdm.models.CouchbaseDatabase
strongdm.models.CouchbaseWebUI
strongdm.models.DB2I
strongdm.models.DB2LUW
strongdm.models.DocumentDBHost
strongdm.models.DocumentDBHostIAM
strongdm.models.DocumentDBReplicaSet
strongdm.models.DocumentDBReplicaSetIAM
strongdm.models.Druid
strongdm.models.DynamoDB
strongdm.models.DynamoDBIAM
strongdm.models.Elastic
strongdm.models.ElasticacheRedis
strongdm.models.GCP
strongdm.models.GCPConsole
strongdm.models.GCPWIF
strongdm.models.GoogleGKE
strongdm.models.GoogleGKEUserImpersonation
strongdm.models.Greenplum
strongdm.models.HTTPAuth
strongdm.models.HTTPBasicAuth
strongdm.models.HTTPNoAuth
strongdm.models.Kubernetes
strongdm.models.KubernetesBasicAuth
strongdm.models.KubernetesPodIdentity
strongdm.models.KubernetesServiceAccount
strongdm.models.KubernetesServiceAccountUserImpersonation
strongdm.models.KubernetesUserImpersonation
strongdm.models.Maria
strongdm.models.Memcached
strongdm.models.Memsql
strongdm.models.MongoHost
strongdm.models.MongoLegacyHost
strongdm.models.MongoLegacyReplicaset
strongdm.models.MongoReplicaSet
strongdm.models.MongoShardedCluster
strongdm.models.MTLSMysql
strongdm.models.MTLSPostgres
strongdm.models.Mysql
strongdm.models.Neptune
strongdm.models.NeptuneIAM
strongdm.models.Oracle
strongdm.models.OracleNNE
strongdm.models.Postgres
strongdm.models.Presto
strongdm.models.RabbitMQAMQP091
strongdm.models.RawTCP
strongdm.models.RDP
strongdm.models.RDPCert
strongdm.models.RDSPostgresIAM
strongdm.models.Redis
strongdm.models.RedisCluster
strongdm.models.Redshift
strongdm.models.RedshiftIAM
strongdm.models.RedshiftServerlessIAM
strongdm.models.SingleStore
strongdm.models.Snowflake
strongdm.models.Snowsight
strongdm.models.SQLServer
strongdm.models.SQLServerAzureAD
strongdm.models.SQLServerKerberosAD
strongdm.models.SSH
strongdm.models.SSHCert
strongdm.models.SSHCustomerKey
strongdm.models.SSHPassword
strongdm.models.Sybase
strongdm.models.SybaseIQ
strongdm.models.Teradata
strongdm.models.Trino
strongdm.models.Vertica
def
create(self, resource, timeout=None)
5239 def create(self, resource, timeout=None): 5240 ''' 5241 Create registers a new Resource. 5242 ''' 5243 deadline = None if timeout is None else time.time() + timeout 5244 req = ResourceCreateRequest() 5245 5246 if resource is not None: 5247 req.resource.CopyFrom( 5248 plumbing.convert_resource_to_plumbing(resource)) 5249 tries = 0 5250 plumbing_response = None 5251 while True: 5252 t = None if deadline is None else deadline - time.time() 5253 try: 5254 plumbing_response = self.stub.Create( 5255 req, 5256 metadata=self.parent.get_metadata('Resources.Create', req), 5257 timeout=t) 5258 except Exception as e: 5259 if self.parent.shouldRetry(tries, e, deadline): 5260 tries += 1 5261 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5262 continue 5263 raise plumbing.convert_error_to_porcelain(e) from e 5264 break 5265 5266 resp = models.ResourceCreateResponse() 5267 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5268 plumbing_response.meta) 5269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5270 plumbing_response.rate_limit) 5271 resp.resource = plumbing.convert_resource_to_porcelain( 5272 plumbing_response.resource) 5273 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
5275 def get(self, id, timeout=None): 5276 ''' 5277 Get reads one Resource by ID. 5278 ''' 5279 deadline = None if timeout is None else time.time() + timeout 5280 req = ResourceGetRequest() 5281 if self.parent.snapshot_datetime is not None: 5282 req.meta.CopyFrom(GetRequestMetadata()) 5283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5284 5285 req.id = (id) 5286 tries = 0 5287 plumbing_response = None 5288 while True: 5289 t = None if deadline is None else deadline - time.time() 5290 try: 5291 plumbing_response = self.stub.Get( 5292 req, 5293 metadata=self.parent.get_metadata('Resources.Get', req), 5294 timeout=t) 5295 except Exception as e: 5296 if self.parent.shouldRetry(tries, e, deadline): 5297 tries += 1 5298 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5299 continue 5300 raise plumbing.convert_error_to_porcelain(e) from e 5301 break 5302 5303 resp = models.ResourceGetResponse() 5304 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5305 plumbing_response.meta) 5306 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5307 plumbing_response.rate_limit) 5308 resp.resource = plumbing.convert_resource_to_porcelain( 5309 plumbing_response.resource) 5310 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
5312 def update(self, resource, timeout=None): 5313 ''' 5314 Update replaces all the fields of a Resource by ID. 5315 ''' 5316 deadline = None if timeout is None else time.time() + timeout 5317 req = ResourceUpdateRequest() 5318 5319 if resource is not None: 5320 req.resource.CopyFrom( 5321 plumbing.convert_resource_to_plumbing(resource)) 5322 tries = 0 5323 plumbing_response = None 5324 while True: 5325 t = None if deadline is None else deadline - time.time() 5326 try: 5327 plumbing_response = self.stub.Update( 5328 req, 5329 metadata=self.parent.get_metadata('Resources.Update', req), 5330 timeout=t) 5331 except Exception as e: 5332 if self.parent.shouldRetry(tries, e, deadline): 5333 tries += 1 5334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5335 continue 5336 raise plumbing.convert_error_to_porcelain(e) from e 5337 break 5338 5339 resp = models.ResourceUpdateResponse() 5340 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5341 plumbing_response.meta) 5342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5343 plumbing_response.rate_limit) 5344 resp.resource = plumbing.convert_resource_to_porcelain( 5345 plumbing_response.resource) 5346 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
5348 def delete(self, id, timeout=None): 5349 ''' 5350 Delete removes a Resource by ID. 5351 ''' 5352 deadline = None if timeout is None else time.time() + timeout 5353 req = ResourceDeleteRequest() 5354 5355 req.id = (id) 5356 tries = 0 5357 plumbing_response = None 5358 while True: 5359 t = None if deadline is None else deadline - time.time() 5360 try: 5361 plumbing_response = self.stub.Delete( 5362 req, 5363 metadata=self.parent.get_metadata('Resources.Delete', req), 5364 timeout=t) 5365 except Exception as e: 5366 if self.parent.shouldRetry(tries, e, deadline): 5367 tries += 1 5368 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5369 continue 5370 raise plumbing.convert_error_to_porcelain(e) from e 5371 break 5372 5373 resp = models.ResourceDeleteResponse() 5374 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5375 plumbing_response.meta) 5376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5377 plumbing_response.rate_limit) 5378 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
5380 def list(self, filter, *args, timeout=None): 5381 ''' 5382 List gets a list of Resources matching a given set of criteria. 5383 ''' 5384 deadline = None if timeout is None else time.time() + timeout 5385 req = ResourceListRequest() 5386 req.meta.CopyFrom(ListRequestMetadata()) 5387 if self.parent.page_limit > 0: 5388 req.meta.limit = self.parent.page_limit 5389 if self.parent.snapshot_datetime is not None: 5390 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5391 5392 req.filter = plumbing.quote_filter_args(filter, *args) 5393 5394 def generator(svc, req): 5395 tries = 0 5396 while True: 5397 t = None if deadline is None else deadline - time.time() 5398 try: 5399 plumbing_response = svc.stub.List( 5400 req, 5401 metadata=svc.parent.get_metadata( 5402 'Resources.List', req), 5403 timeout=t) 5404 except Exception as e: 5405 if self.parent.shouldRetry(tries, e, deadline): 5406 tries += 1 5407 time.sleep( 5408 self.parent.exponentialBackoff(tries, deadline)) 5409 continue 5410 raise plumbing.convert_error_to_porcelain(e) from e 5411 tries = 0 5412 for plumbing_item in plumbing_response.resources: 5413 yield plumbing.convert_resource_to_porcelain(plumbing_item) 5414 if plumbing_response.meta.next_cursor == '': 5415 break 5416 req.meta.cursor = plumbing_response.meta.next_cursor 5417 5418 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
5420 def healthcheck(self, id, timeout=None): 5421 ''' 5422 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 5423 large network of Nodes. The call will return immediately, and the updated health of the 5424 Resource can be retrieved via Get or List. 5425 ''' 5426 deadline = None if timeout is None else time.time() + timeout 5427 req = ResourceHealthcheckRequest() 5428 5429 req.id = (id) 5430 tries = 0 5431 plumbing_response = None 5432 while True: 5433 t = None if deadline is None else deadline - time.time() 5434 try: 5435 plumbing_response = self.stub.Healthcheck( 5436 req, 5437 metadata=self.parent.get_metadata('Resources.Healthcheck', 5438 req), 5439 timeout=t) 5440 except Exception as e: 5441 if self.parent.shouldRetry(tries, e, deadline): 5442 tries += 1 5443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5444 continue 5445 raise plumbing.convert_error_to_porcelain(e) from e 5446 break 5447 5448 resp = models.ResourceHealthcheckResponse() 5449 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5450 plumbing_response.meta) 5451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5452 plumbing_response.rate_limit) 5453 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:
5456class SnapshotResources: 5457 ''' 5458 SnapshotResources exposes the read only methods of the Resources 5459 service for historical queries. 5460 ''' 5461 def __init__(self, resources): 5462 self.resources = resources 5463 5464 def get(self, id, timeout=None): 5465 ''' 5466 Get reads one Resource by ID. 5467 ''' 5468 return self.resources.get(id, timeout=timeout) 5469 5470 def list(self, filter, *args, timeout=None): 5471 ''' 5472 List gets a list of Resources matching a given set of criteria. 5473 ''' 5474 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)
5464 def get(self, id, timeout=None): 5465 ''' 5466 Get reads one Resource by ID. 5467 ''' 5468 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
5470 def list(self, filter, *args, timeout=None): 5471 ''' 5472 List gets a list of Resources matching a given set of criteria. 5473 ''' 5474 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
5477class ResourcesHistory: 5478 ''' 5479 ResourcesHistory records all changes to the state of a Resource. 5480 See `strongdm.models.ResourceHistory`. 5481 ''' 5482 def __init__(self, channel, client): 5483 self.parent = client 5484 self.stub = ResourcesHistoryStub(channel) 5485 5486 def list(self, filter, *args, timeout=None): 5487 ''' 5488 List gets a list of ResourceHistory records matching a given set of criteria. 5489 ''' 5490 deadline = None if timeout is None else time.time() + timeout 5491 req = ResourceHistoryListRequest() 5492 req.meta.CopyFrom(ListRequestMetadata()) 5493 if self.parent.page_limit > 0: 5494 req.meta.limit = self.parent.page_limit 5495 if self.parent.snapshot_datetime is not None: 5496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5497 5498 req.filter = plumbing.quote_filter_args(filter, *args) 5499 5500 def generator(svc, req): 5501 tries = 0 5502 while True: 5503 t = None if deadline is None else deadline - time.time() 5504 try: 5505 plumbing_response = svc.stub.List( 5506 req, 5507 metadata=svc.parent.get_metadata( 5508 'ResourcesHistory.List', req), 5509 timeout=t) 5510 except Exception as e: 5511 if self.parent.shouldRetry(tries, e, deadline): 5512 tries += 1 5513 time.sleep( 5514 self.parent.exponentialBackoff(tries, deadline)) 5515 continue 5516 raise plumbing.convert_error_to_porcelain(e) from e 5517 tries = 0 5518 for plumbing_item in plumbing_response.history: 5519 yield plumbing.convert_resource_history_to_porcelain( 5520 plumbing_item) 5521 if plumbing_response.meta.next_cursor == '': 5522 break 5523 req.meta.cursor = plumbing_response.meta.next_cursor 5524 5525 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)
5486 def list(self, filter, *args, timeout=None): 5487 ''' 5488 List gets a list of ResourceHistory records matching a given set of criteria. 5489 ''' 5490 deadline = None if timeout is None else time.time() + timeout 5491 req = ResourceHistoryListRequest() 5492 req.meta.CopyFrom(ListRequestMetadata()) 5493 if self.parent.page_limit > 0: 5494 req.meta.limit = self.parent.page_limit 5495 if self.parent.snapshot_datetime is not None: 5496 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5497 5498 req.filter = plumbing.quote_filter_args(filter, *args) 5499 5500 def generator(svc, req): 5501 tries = 0 5502 while True: 5503 t = None if deadline is None else deadline - time.time() 5504 try: 5505 plumbing_response = svc.stub.List( 5506 req, 5507 metadata=svc.parent.get_metadata( 5508 'ResourcesHistory.List', req), 5509 timeout=t) 5510 except Exception as e: 5511 if self.parent.shouldRetry(tries, e, deadline): 5512 tries += 1 5513 time.sleep( 5514 self.parent.exponentialBackoff(tries, deadline)) 5515 continue 5516 raise plumbing.convert_error_to_porcelain(e) from e 5517 tries = 0 5518 for plumbing_item in plumbing_response.history: 5519 yield plumbing.convert_resource_history_to_porcelain( 5520 plumbing_item) 5521 if plumbing_response.meta.next_cursor == '': 5522 break 5523 req.meta.cursor = plumbing_response.meta.next_cursor 5524 5525 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
5528class RoleResources: 5529 ''' 5530 RoleResources enumerates the resources to which roles have access. 5531 The RoleResources service is read-only. 5532 See `strongdm.models.RoleResource`. 5533 ''' 5534 def __init__(self, channel, client): 5535 self.parent = client 5536 self.stub = RoleResourcesStub(channel) 5537 5538 def list(self, filter, *args, timeout=None): 5539 ''' 5540 List gets a list of RoleResource records matching a given set of criteria. 5541 ''' 5542 deadline = None if timeout is None else time.time() + timeout 5543 req = RoleResourceListRequest() 5544 req.meta.CopyFrom(ListRequestMetadata()) 5545 if self.parent.page_limit > 0: 5546 req.meta.limit = self.parent.page_limit 5547 if self.parent.snapshot_datetime is not None: 5548 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5549 5550 req.filter = plumbing.quote_filter_args(filter, *args) 5551 5552 def generator(svc, req): 5553 tries = 0 5554 while True: 5555 t = None if deadline is None else deadline - time.time() 5556 try: 5557 plumbing_response = svc.stub.List( 5558 req, 5559 metadata=svc.parent.get_metadata( 5560 'RoleResources.List', req), 5561 timeout=t) 5562 except Exception as e: 5563 if self.parent.shouldRetry(tries, e, deadline): 5564 tries += 1 5565 time.sleep( 5566 self.parent.exponentialBackoff(tries, deadline)) 5567 continue 5568 raise plumbing.convert_error_to_porcelain(e) from e 5569 tries = 0 5570 for plumbing_item in plumbing_response.role_resources: 5571 yield plumbing.convert_role_resource_to_porcelain( 5572 plumbing_item) 5573 if plumbing_response.meta.next_cursor == '': 5574 break 5575 req.meta.cursor = plumbing_response.meta.next_cursor 5576 5577 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)
5538 def list(self, filter, *args, timeout=None): 5539 ''' 5540 List gets a list of RoleResource records matching a given set of criteria. 5541 ''' 5542 deadline = None if timeout is None else time.time() + timeout 5543 req = RoleResourceListRequest() 5544 req.meta.CopyFrom(ListRequestMetadata()) 5545 if self.parent.page_limit > 0: 5546 req.meta.limit = self.parent.page_limit 5547 if self.parent.snapshot_datetime is not None: 5548 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5549 5550 req.filter = plumbing.quote_filter_args(filter, *args) 5551 5552 def generator(svc, req): 5553 tries = 0 5554 while True: 5555 t = None if deadline is None else deadline - time.time() 5556 try: 5557 plumbing_response = svc.stub.List( 5558 req, 5559 metadata=svc.parent.get_metadata( 5560 'RoleResources.List', req), 5561 timeout=t) 5562 except Exception as e: 5563 if self.parent.shouldRetry(tries, e, deadline): 5564 tries += 1 5565 time.sleep( 5566 self.parent.exponentialBackoff(tries, deadline)) 5567 continue 5568 raise plumbing.convert_error_to_porcelain(e) from e 5569 tries = 0 5570 for plumbing_item in plumbing_response.role_resources: 5571 yield plumbing.convert_role_resource_to_porcelain( 5572 plumbing_item) 5573 if plumbing_response.meta.next_cursor == '': 5574 break 5575 req.meta.cursor = plumbing_response.meta.next_cursor 5576 5577 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
5580class SnapshotRoleResources: 5581 ''' 5582 SnapshotRoleResources exposes the read only methods of the RoleResources 5583 service for historical queries. 5584 ''' 5585 def __init__(self, role_resources): 5586 self.role_resources = role_resources 5587 5588 def list(self, filter, *args, timeout=None): 5589 ''' 5590 List gets a list of RoleResource records matching a given set of criteria. 5591 ''' 5592 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)
5588 def list(self, filter, *args, timeout=None): 5589 ''' 5590 List gets a list of RoleResource records matching a given set of criteria. 5591 ''' 5592 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
5595class RoleResourcesHistory: 5596 ''' 5597 RoleResourcesHistory records all changes to the state of a RoleResource. 5598 See `strongdm.models.RoleResourceHistory`. 5599 ''' 5600 def __init__(self, channel, client): 5601 self.parent = client 5602 self.stub = RoleResourcesHistoryStub(channel) 5603 5604 def list(self, filter, *args, timeout=None): 5605 ''' 5606 List gets a list of RoleResourceHistory records matching a given set of criteria. 5607 ''' 5608 deadline = None if timeout is None else time.time() + timeout 5609 req = RoleResourceHistoryListRequest() 5610 req.meta.CopyFrom(ListRequestMetadata()) 5611 if self.parent.page_limit > 0: 5612 req.meta.limit = self.parent.page_limit 5613 if self.parent.snapshot_datetime is not None: 5614 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5615 5616 req.filter = plumbing.quote_filter_args(filter, *args) 5617 5618 def generator(svc, req): 5619 tries = 0 5620 while True: 5621 t = None if deadline is None else deadline - time.time() 5622 try: 5623 plumbing_response = svc.stub.List( 5624 req, 5625 metadata=svc.parent.get_metadata( 5626 'RoleResourcesHistory.List', req), 5627 timeout=t) 5628 except Exception as e: 5629 if self.parent.shouldRetry(tries, e, deadline): 5630 tries += 1 5631 time.sleep( 5632 self.parent.exponentialBackoff(tries, deadline)) 5633 continue 5634 raise plumbing.convert_error_to_porcelain(e) from e 5635 tries = 0 5636 for plumbing_item in plumbing_response.history: 5637 yield plumbing.convert_role_resource_history_to_porcelain( 5638 plumbing_item) 5639 if plumbing_response.meta.next_cursor == '': 5640 break 5641 req.meta.cursor = plumbing_response.meta.next_cursor 5642 5643 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)
5604 def list(self, filter, *args, timeout=None): 5605 ''' 5606 List gets a list of RoleResourceHistory records matching a given set of criteria. 5607 ''' 5608 deadline = None if timeout is None else time.time() + timeout 5609 req = RoleResourceHistoryListRequest() 5610 req.meta.CopyFrom(ListRequestMetadata()) 5611 if self.parent.page_limit > 0: 5612 req.meta.limit = self.parent.page_limit 5613 if self.parent.snapshot_datetime is not None: 5614 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5615 5616 req.filter = plumbing.quote_filter_args(filter, *args) 5617 5618 def generator(svc, req): 5619 tries = 0 5620 while True: 5621 t = None if deadline is None else deadline - time.time() 5622 try: 5623 plumbing_response = svc.stub.List( 5624 req, 5625 metadata=svc.parent.get_metadata( 5626 'RoleResourcesHistory.List', req), 5627 timeout=t) 5628 except Exception as e: 5629 if self.parent.shouldRetry(tries, e, deadline): 5630 tries += 1 5631 time.sleep( 5632 self.parent.exponentialBackoff(tries, deadline)) 5633 continue 5634 raise plumbing.convert_error_to_porcelain(e) from e 5635 tries = 0 5636 for plumbing_item in plumbing_response.history: 5637 yield plumbing.convert_role_resource_history_to_porcelain( 5638 plumbing_item) 5639 if plumbing_response.meta.next_cursor == '': 5640 break 5641 req.meta.cursor = plumbing_response.meta.next_cursor 5642 5643 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
Roles:
5646class Roles: 5647 ''' 5648 A Role has a list of access rules which determine which Resources the members 5649 of the Role have access to. An Account can be a member of multiple Roles via 5650 AccountAttachments. 5651 See `strongdm.models.Role`. 5652 ''' 5653 def __init__(self, channel, client): 5654 self.parent = client 5655 self.stub = RolesStub(channel) 5656 5657 def create(self, role, timeout=None): 5658 ''' 5659 Create registers a new Role. 5660 ''' 5661 deadline = None if timeout is None else time.time() + timeout 5662 req = RoleCreateRequest() 5663 5664 if role is not None: 5665 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5666 tries = 0 5667 plumbing_response = None 5668 while True: 5669 t = None if deadline is None else deadline - time.time() 5670 try: 5671 plumbing_response = self.stub.Create( 5672 req, 5673 metadata=self.parent.get_metadata('Roles.Create', req), 5674 timeout=t) 5675 except Exception as e: 5676 if self.parent.shouldRetry(tries, e, deadline): 5677 tries += 1 5678 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5679 continue 5680 raise plumbing.convert_error_to_porcelain(e) from e 5681 break 5682 5683 resp = models.RoleCreateResponse() 5684 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5685 plumbing_response.meta) 5686 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5687 plumbing_response.rate_limit) 5688 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5689 return resp 5690 5691 def get(self, id, timeout=None): 5692 ''' 5693 Get reads one Role by ID. 5694 ''' 5695 deadline = None if timeout is None else time.time() + timeout 5696 req = RoleGetRequest() 5697 if self.parent.snapshot_datetime is not None: 5698 req.meta.CopyFrom(GetRequestMetadata()) 5699 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5700 5701 req.id = (id) 5702 tries = 0 5703 plumbing_response = None 5704 while True: 5705 t = None if deadline is None else deadline - time.time() 5706 try: 5707 plumbing_response = self.stub.Get( 5708 req, 5709 metadata=self.parent.get_metadata('Roles.Get', req), 5710 timeout=t) 5711 except Exception as e: 5712 if self.parent.shouldRetry(tries, e, deadline): 5713 tries += 1 5714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5715 continue 5716 raise plumbing.convert_error_to_porcelain(e) from e 5717 break 5718 5719 resp = models.RoleGetResponse() 5720 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5721 plumbing_response.meta) 5722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5723 plumbing_response.rate_limit) 5724 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5725 return resp 5726 5727 def update(self, role, timeout=None): 5728 ''' 5729 Update replaces all the fields of a Role by ID. 5730 ''' 5731 deadline = None if timeout is None else time.time() + timeout 5732 req = RoleUpdateRequest() 5733 5734 if role is not None: 5735 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5736 tries = 0 5737 plumbing_response = None 5738 while True: 5739 t = None if deadline is None else deadline - time.time() 5740 try: 5741 plumbing_response = self.stub.Update( 5742 req, 5743 metadata=self.parent.get_metadata('Roles.Update', req), 5744 timeout=t) 5745 except Exception as e: 5746 if self.parent.shouldRetry(tries, e, deadline): 5747 tries += 1 5748 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5749 continue 5750 raise plumbing.convert_error_to_porcelain(e) from e 5751 break 5752 5753 resp = models.RoleUpdateResponse() 5754 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5755 plumbing_response.meta) 5756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5757 plumbing_response.rate_limit) 5758 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5759 return resp 5760 5761 def delete(self, id, timeout=None): 5762 ''' 5763 Delete removes a Role by ID. 5764 ''' 5765 deadline = None if timeout is None else time.time() + timeout 5766 req = RoleDeleteRequest() 5767 5768 req.id = (id) 5769 tries = 0 5770 plumbing_response = None 5771 while True: 5772 t = None if deadline is None else deadline - time.time() 5773 try: 5774 plumbing_response = self.stub.Delete( 5775 req, 5776 metadata=self.parent.get_metadata('Roles.Delete', req), 5777 timeout=t) 5778 except Exception as e: 5779 if self.parent.shouldRetry(tries, e, deadline): 5780 tries += 1 5781 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5782 continue 5783 raise plumbing.convert_error_to_porcelain(e) from e 5784 break 5785 5786 resp = models.RoleDeleteResponse() 5787 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5788 plumbing_response.meta) 5789 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5790 plumbing_response.rate_limit) 5791 return resp 5792 5793 def list(self, filter, *args, timeout=None): 5794 ''' 5795 List gets a list of Roles matching a given set of criteria. 5796 ''' 5797 deadline = None if timeout is None else time.time() + timeout 5798 req = RoleListRequest() 5799 req.meta.CopyFrom(ListRequestMetadata()) 5800 if self.parent.page_limit > 0: 5801 req.meta.limit = self.parent.page_limit 5802 if self.parent.snapshot_datetime is not None: 5803 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5804 5805 req.filter = plumbing.quote_filter_args(filter, *args) 5806 5807 def generator(svc, req): 5808 tries = 0 5809 while True: 5810 t = None if deadline is None else deadline - time.time() 5811 try: 5812 plumbing_response = svc.stub.List( 5813 req, 5814 metadata=svc.parent.get_metadata('Roles.List', req), 5815 timeout=t) 5816 except Exception as e: 5817 if self.parent.shouldRetry(tries, e, deadline): 5818 tries += 1 5819 time.sleep( 5820 self.parent.exponentialBackoff(tries, deadline)) 5821 continue 5822 raise plumbing.convert_error_to_porcelain(e) from e 5823 tries = 0 5824 for plumbing_item in plumbing_response.roles: 5825 yield plumbing.convert_role_to_porcelain(plumbing_item) 5826 if plumbing_response.meta.next_cursor == '': 5827 break 5828 req.meta.cursor = plumbing_response.meta.next_cursor 5829 5830 return generator(self, req)
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)
5657 def create(self, role, timeout=None): 5658 ''' 5659 Create registers a new Role. 5660 ''' 5661 deadline = None if timeout is None else time.time() + timeout 5662 req = RoleCreateRequest() 5663 5664 if role is not None: 5665 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5666 tries = 0 5667 plumbing_response = None 5668 while True: 5669 t = None if deadline is None else deadline - time.time() 5670 try: 5671 plumbing_response = self.stub.Create( 5672 req, 5673 metadata=self.parent.get_metadata('Roles.Create', req), 5674 timeout=t) 5675 except Exception as e: 5676 if self.parent.shouldRetry(tries, e, deadline): 5677 tries += 1 5678 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5679 continue 5680 raise plumbing.convert_error_to_porcelain(e) from e 5681 break 5682 5683 resp = models.RoleCreateResponse() 5684 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5685 plumbing_response.meta) 5686 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5687 plumbing_response.rate_limit) 5688 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5689 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
5691 def get(self, id, timeout=None): 5692 ''' 5693 Get reads one Role by ID. 5694 ''' 5695 deadline = None if timeout is None else time.time() + timeout 5696 req = RoleGetRequest() 5697 if self.parent.snapshot_datetime is not None: 5698 req.meta.CopyFrom(GetRequestMetadata()) 5699 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5700 5701 req.id = (id) 5702 tries = 0 5703 plumbing_response = None 5704 while True: 5705 t = None if deadline is None else deadline - time.time() 5706 try: 5707 plumbing_response = self.stub.Get( 5708 req, 5709 metadata=self.parent.get_metadata('Roles.Get', req), 5710 timeout=t) 5711 except Exception as e: 5712 if self.parent.shouldRetry(tries, e, deadline): 5713 tries += 1 5714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5715 continue 5716 raise plumbing.convert_error_to_porcelain(e) from e 5717 break 5718 5719 resp = models.RoleGetResponse() 5720 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5721 plumbing_response.meta) 5722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5723 plumbing_response.rate_limit) 5724 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5725 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
5727 def update(self, role, timeout=None): 5728 ''' 5729 Update replaces all the fields of a Role by ID. 5730 ''' 5731 deadline = None if timeout is None else time.time() + timeout 5732 req = RoleUpdateRequest() 5733 5734 if role is not None: 5735 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 5736 tries = 0 5737 plumbing_response = None 5738 while True: 5739 t = None if deadline is None else deadline - time.time() 5740 try: 5741 plumbing_response = self.stub.Update( 5742 req, 5743 metadata=self.parent.get_metadata('Roles.Update', req), 5744 timeout=t) 5745 except Exception as e: 5746 if self.parent.shouldRetry(tries, e, deadline): 5747 tries += 1 5748 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5749 continue 5750 raise plumbing.convert_error_to_porcelain(e) from e 5751 break 5752 5753 resp = models.RoleUpdateResponse() 5754 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5755 plumbing_response.meta) 5756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5757 plumbing_response.rate_limit) 5758 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 5759 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
5761 def delete(self, id, timeout=None): 5762 ''' 5763 Delete removes a Role by ID. 5764 ''' 5765 deadline = None if timeout is None else time.time() + timeout 5766 req = RoleDeleteRequest() 5767 5768 req.id = (id) 5769 tries = 0 5770 plumbing_response = None 5771 while True: 5772 t = None if deadline is None else deadline - time.time() 5773 try: 5774 plumbing_response = self.stub.Delete( 5775 req, 5776 metadata=self.parent.get_metadata('Roles.Delete', req), 5777 timeout=t) 5778 except Exception as e: 5779 if self.parent.shouldRetry(tries, e, deadline): 5780 tries += 1 5781 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5782 continue 5783 raise plumbing.convert_error_to_porcelain(e) from e 5784 break 5785 5786 resp = models.RoleDeleteResponse() 5787 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5788 plumbing_response.meta) 5789 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5790 plumbing_response.rate_limit) 5791 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
5793 def list(self, filter, *args, timeout=None): 5794 ''' 5795 List gets a list of Roles matching a given set of criteria. 5796 ''' 5797 deadline = None if timeout is None else time.time() + timeout 5798 req = RoleListRequest() 5799 req.meta.CopyFrom(ListRequestMetadata()) 5800 if self.parent.page_limit > 0: 5801 req.meta.limit = self.parent.page_limit 5802 if self.parent.snapshot_datetime is not None: 5803 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5804 5805 req.filter = plumbing.quote_filter_args(filter, *args) 5806 5807 def generator(svc, req): 5808 tries = 0 5809 while True: 5810 t = None if deadline is None else deadline - time.time() 5811 try: 5812 plumbing_response = svc.stub.List( 5813 req, 5814 metadata=svc.parent.get_metadata('Roles.List', req), 5815 timeout=t) 5816 except Exception as e: 5817 if self.parent.shouldRetry(tries, e, deadline): 5818 tries += 1 5819 time.sleep( 5820 self.parent.exponentialBackoff(tries, deadline)) 5821 continue 5822 raise plumbing.convert_error_to_porcelain(e) from e 5823 tries = 0 5824 for plumbing_item in plumbing_response.roles: 5825 yield plumbing.convert_role_to_porcelain(plumbing_item) 5826 if plumbing_response.meta.next_cursor == '': 5827 break 5828 req.meta.cursor = plumbing_response.meta.next_cursor 5829 5830 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
5833class SnapshotRoles: 5834 ''' 5835 SnapshotRoles exposes the read only methods of the Roles 5836 service for historical queries. 5837 ''' 5838 def __init__(self, roles): 5839 self.roles = roles 5840 5841 def get(self, id, timeout=None): 5842 ''' 5843 Get reads one Role by ID. 5844 ''' 5845 return self.roles.get(id, timeout=timeout) 5846 5847 def list(self, filter, *args, timeout=None): 5848 ''' 5849 List gets a list of Roles matching a given set of criteria. 5850 ''' 5851 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
RolesHistory:
5854class RolesHistory: 5855 ''' 5856 RolesHistory records all changes to the state of a Role. 5857 See `strongdm.models.RoleHistory`. 5858 ''' 5859 def __init__(self, channel, client): 5860 self.parent = client 5861 self.stub = RolesHistoryStub(channel) 5862 5863 def list(self, filter, *args, timeout=None): 5864 ''' 5865 List gets a list of RoleHistory records matching a given set of criteria. 5866 ''' 5867 deadline = None if timeout is None else time.time() + timeout 5868 req = RoleHistoryListRequest() 5869 req.meta.CopyFrom(ListRequestMetadata()) 5870 if self.parent.page_limit > 0: 5871 req.meta.limit = self.parent.page_limit 5872 if self.parent.snapshot_datetime is not None: 5873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5874 5875 req.filter = plumbing.quote_filter_args(filter, *args) 5876 5877 def generator(svc, req): 5878 tries = 0 5879 while True: 5880 t = None if deadline is None else deadline - time.time() 5881 try: 5882 plumbing_response = svc.stub.List( 5883 req, 5884 metadata=svc.parent.get_metadata( 5885 'RolesHistory.List', req), 5886 timeout=t) 5887 except Exception as e: 5888 if self.parent.shouldRetry(tries, e, deadline): 5889 tries += 1 5890 time.sleep( 5891 self.parent.exponentialBackoff(tries, deadline)) 5892 continue 5893 raise plumbing.convert_error_to_porcelain(e) from e 5894 tries = 0 5895 for plumbing_item in plumbing_response.history: 5896 yield plumbing.convert_role_history_to_porcelain( 5897 plumbing_item) 5898 if plumbing_response.meta.next_cursor == '': 5899 break 5900 req.meta.cursor = plumbing_response.meta.next_cursor 5901 5902 return generator(self, req)
RolesHistory records all changes to the state of a Role.
See strongdm.models.RoleHistory.
def
list(self, filter, *args, timeout=None)
5863 def list(self, filter, *args, timeout=None): 5864 ''' 5865 List gets a list of RoleHistory records matching a given set of criteria. 5866 ''' 5867 deadline = None if timeout is None else time.time() + timeout 5868 req = RoleHistoryListRequest() 5869 req.meta.CopyFrom(ListRequestMetadata()) 5870 if self.parent.page_limit > 0: 5871 req.meta.limit = self.parent.page_limit 5872 if self.parent.snapshot_datetime is not None: 5873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5874 5875 req.filter = plumbing.quote_filter_args(filter, *args) 5876 5877 def generator(svc, req): 5878 tries = 0 5879 while True: 5880 t = None if deadline is None else deadline - time.time() 5881 try: 5882 plumbing_response = svc.stub.List( 5883 req, 5884 metadata=svc.parent.get_metadata( 5885 'RolesHistory.List', req), 5886 timeout=t) 5887 except Exception as e: 5888 if self.parent.shouldRetry(tries, e, deadline): 5889 tries += 1 5890 time.sleep( 5891 self.parent.exponentialBackoff(tries, deadline)) 5892 continue 5893 raise plumbing.convert_error_to_porcelain(e) from e 5894 tries = 0 5895 for plumbing_item in plumbing_response.history: 5896 yield plumbing.convert_role_history_to_porcelain( 5897 plumbing_item) 5898 if plumbing_response.meta.next_cursor == '': 5899 break 5900 req.meta.cursor = plumbing_response.meta.next_cursor 5901 5902 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
5905class SecretStores: 5906 ''' 5907 SecretStores are servers where resource secrets (passwords, keys) are stored. 5908 See: 5909 `strongdm.models.ActiveDirectoryStore` 5910 `strongdm.models.AWSStore` 5911 `strongdm.models.AWSCertX509Store` 5912 `strongdm.models.AzureStore` 5913 `strongdm.models.CyberarkConjurStore` 5914 `strongdm.models.CyberarkPAMStore` 5915 `strongdm.models.CyberarkPAMExperimentalStore` 5916 `strongdm.models.DelineaStore` 5917 `strongdm.models.GCPStore` 5918 `strongdm.models.GCPCertX509Store` 5919 `strongdm.models.KeyfactorSSHStore` 5920 `strongdm.models.KeyfactorX509Store` 5921 `strongdm.models.VaultAppRoleStore` 5922 `strongdm.models.VaultAppRoleCertSSHStore` 5923 `strongdm.models.VaultAppRoleCertX509Store` 5924 `strongdm.models.VaultAWSEC2Store` 5925 `strongdm.models.VaultAWSIAMStore` 5926 `strongdm.models.VaultTLSStore` 5927 `strongdm.models.VaultTLSCertSSHStore` 5928 `strongdm.models.VaultTLSCertX509Store` 5929 `strongdm.models.VaultTokenStore` 5930 `strongdm.models.VaultTokenCertSSHStore` 5931 `strongdm.models.VaultTokenCertX509Store` 5932 ''' 5933 def __init__(self, channel, client): 5934 self.parent = client 5935 self.stub = SecretStoresStub(channel) 5936 5937 def create(self, secret_store, timeout=None): 5938 deadline = None if timeout is None else time.time() + timeout 5939 req = SecretStoreCreateRequest() 5940 5941 if secret_store is not None: 5942 req.secret_store.CopyFrom( 5943 plumbing.convert_secret_store_to_plumbing(secret_store)) 5944 tries = 0 5945 plumbing_response = None 5946 while True: 5947 t = None if deadline is None else deadline - time.time() 5948 try: 5949 plumbing_response = self.stub.Create( 5950 req, 5951 metadata=self.parent.get_metadata('SecretStores.Create', 5952 req), 5953 timeout=t) 5954 except Exception as e: 5955 if self.parent.shouldRetry(tries, e, deadline): 5956 tries += 1 5957 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5958 continue 5959 raise plumbing.convert_error_to_porcelain(e) from e 5960 break 5961 5962 resp = models.SecretStoreCreateResponse() 5963 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5964 plumbing_response.meta) 5965 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5966 plumbing_response.rate_limit) 5967 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5968 plumbing_response.secret_store) 5969 return resp 5970 5971 def get(self, id, timeout=None): 5972 ''' 5973 Get reads one SecretStore by ID. 5974 ''' 5975 deadline = None if timeout is None else time.time() + timeout 5976 req = SecretStoreGetRequest() 5977 if self.parent.snapshot_datetime is not None: 5978 req.meta.CopyFrom(GetRequestMetadata()) 5979 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5980 5981 req.id = (id) 5982 tries = 0 5983 plumbing_response = None 5984 while True: 5985 t = None if deadline is None else deadline - time.time() 5986 try: 5987 plumbing_response = self.stub.Get( 5988 req, 5989 metadata=self.parent.get_metadata('SecretStores.Get', req), 5990 timeout=t) 5991 except Exception as e: 5992 if self.parent.shouldRetry(tries, e, deadline): 5993 tries += 1 5994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5995 continue 5996 raise plumbing.convert_error_to_porcelain(e) from e 5997 break 5998 5999 resp = models.SecretStoreGetResponse() 6000 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6001 plumbing_response.meta) 6002 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6003 plumbing_response.rate_limit) 6004 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6005 plumbing_response.secret_store) 6006 return resp 6007 6008 def update(self, secret_store, timeout=None): 6009 ''' 6010 Update replaces all the fields of a SecretStore by ID. 6011 ''' 6012 deadline = None if timeout is None else time.time() + timeout 6013 req = SecretStoreUpdateRequest() 6014 6015 if secret_store is not None: 6016 req.secret_store.CopyFrom( 6017 plumbing.convert_secret_store_to_plumbing(secret_store)) 6018 tries = 0 6019 plumbing_response = None 6020 while True: 6021 t = None if deadline is None else deadline - time.time() 6022 try: 6023 plumbing_response = self.stub.Update( 6024 req, 6025 metadata=self.parent.get_metadata('SecretStores.Update', 6026 req), 6027 timeout=t) 6028 except Exception as e: 6029 if self.parent.shouldRetry(tries, e, deadline): 6030 tries += 1 6031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6032 continue 6033 raise plumbing.convert_error_to_porcelain(e) from e 6034 break 6035 6036 resp = models.SecretStoreUpdateResponse() 6037 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6038 plumbing_response.meta) 6039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6040 plumbing_response.rate_limit) 6041 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6042 plumbing_response.secret_store) 6043 return resp 6044 6045 def delete(self, id, timeout=None): 6046 ''' 6047 Delete removes a SecretStore by ID. 6048 ''' 6049 deadline = None if timeout is None else time.time() + timeout 6050 req = SecretStoreDeleteRequest() 6051 6052 req.id = (id) 6053 tries = 0 6054 plumbing_response = None 6055 while True: 6056 t = None if deadline is None else deadline - time.time() 6057 try: 6058 plumbing_response = self.stub.Delete( 6059 req, 6060 metadata=self.parent.get_metadata('SecretStores.Delete', 6061 req), 6062 timeout=t) 6063 except Exception as e: 6064 if self.parent.shouldRetry(tries, e, deadline): 6065 tries += 1 6066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6067 continue 6068 raise plumbing.convert_error_to_porcelain(e) from e 6069 break 6070 6071 resp = models.SecretStoreDeleteResponse() 6072 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6073 plumbing_response.meta) 6074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6075 plumbing_response.rate_limit) 6076 return resp 6077 6078 def list(self, filter, *args, timeout=None): 6079 ''' 6080 List gets a list of SecretStores matching a given set of criteria. 6081 ''' 6082 deadline = None if timeout is None else time.time() + timeout 6083 req = SecretStoreListRequest() 6084 req.meta.CopyFrom(ListRequestMetadata()) 6085 if self.parent.page_limit > 0: 6086 req.meta.limit = self.parent.page_limit 6087 if self.parent.snapshot_datetime is not None: 6088 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6089 6090 req.filter = plumbing.quote_filter_args(filter, *args) 6091 6092 def generator(svc, req): 6093 tries = 0 6094 while True: 6095 t = None if deadline is None else deadline - time.time() 6096 try: 6097 plumbing_response = svc.stub.List( 6098 req, 6099 metadata=svc.parent.get_metadata( 6100 'SecretStores.List', req), 6101 timeout=t) 6102 except Exception as e: 6103 if self.parent.shouldRetry(tries, e, deadline): 6104 tries += 1 6105 time.sleep( 6106 self.parent.exponentialBackoff(tries, deadline)) 6107 continue 6108 raise plumbing.convert_error_to_porcelain(e) from e 6109 tries = 0 6110 for plumbing_item in plumbing_response.secret_stores: 6111 yield plumbing.convert_secret_store_to_porcelain( 6112 plumbing_item) 6113 if plumbing_response.meta.next_cursor == '': 6114 break 6115 req.meta.cursor = plumbing_response.meta.next_cursor 6116 6117 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)
5937 def create(self, secret_store, timeout=None): 5938 deadline = None if timeout is None else time.time() + timeout 5939 req = SecretStoreCreateRequest() 5940 5941 if secret_store is not None: 5942 req.secret_store.CopyFrom( 5943 plumbing.convert_secret_store_to_plumbing(secret_store)) 5944 tries = 0 5945 plumbing_response = None 5946 while True: 5947 t = None if deadline is None else deadline - time.time() 5948 try: 5949 plumbing_response = self.stub.Create( 5950 req, 5951 metadata=self.parent.get_metadata('SecretStores.Create', 5952 req), 5953 timeout=t) 5954 except Exception as e: 5955 if self.parent.shouldRetry(tries, e, deadline): 5956 tries += 1 5957 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5958 continue 5959 raise plumbing.convert_error_to_porcelain(e) from e 5960 break 5961 5962 resp = models.SecretStoreCreateResponse() 5963 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5964 plumbing_response.meta) 5965 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5966 plumbing_response.rate_limit) 5967 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 5968 plumbing_response.secret_store) 5969 return resp
def
get(self, id, timeout=None)
5971 def get(self, id, timeout=None): 5972 ''' 5973 Get reads one SecretStore by ID. 5974 ''' 5975 deadline = None if timeout is None else time.time() + timeout 5976 req = SecretStoreGetRequest() 5977 if self.parent.snapshot_datetime is not None: 5978 req.meta.CopyFrom(GetRequestMetadata()) 5979 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5980 5981 req.id = (id) 5982 tries = 0 5983 plumbing_response = None 5984 while True: 5985 t = None if deadline is None else deadline - time.time() 5986 try: 5987 plumbing_response = self.stub.Get( 5988 req, 5989 metadata=self.parent.get_metadata('SecretStores.Get', req), 5990 timeout=t) 5991 except Exception as e: 5992 if self.parent.shouldRetry(tries, e, deadline): 5993 tries += 1 5994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5995 continue 5996 raise plumbing.convert_error_to_porcelain(e) from e 5997 break 5998 5999 resp = models.SecretStoreGetResponse() 6000 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6001 plumbing_response.meta) 6002 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6003 plumbing_response.rate_limit) 6004 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6005 plumbing_response.secret_store) 6006 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
6008 def update(self, secret_store, timeout=None): 6009 ''' 6010 Update replaces all the fields of a SecretStore by ID. 6011 ''' 6012 deadline = None if timeout is None else time.time() + timeout 6013 req = SecretStoreUpdateRequest() 6014 6015 if secret_store is not None: 6016 req.secret_store.CopyFrom( 6017 plumbing.convert_secret_store_to_plumbing(secret_store)) 6018 tries = 0 6019 plumbing_response = None 6020 while True: 6021 t = None if deadline is None else deadline - time.time() 6022 try: 6023 plumbing_response = self.stub.Update( 6024 req, 6025 metadata=self.parent.get_metadata('SecretStores.Update', 6026 req), 6027 timeout=t) 6028 except Exception as e: 6029 if self.parent.shouldRetry(tries, e, deadline): 6030 tries += 1 6031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6032 continue 6033 raise plumbing.convert_error_to_porcelain(e) from e 6034 break 6035 6036 resp = models.SecretStoreUpdateResponse() 6037 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6038 plumbing_response.meta) 6039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6040 plumbing_response.rate_limit) 6041 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6042 plumbing_response.secret_store) 6043 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
6045 def delete(self, id, timeout=None): 6046 ''' 6047 Delete removes a SecretStore by ID. 6048 ''' 6049 deadline = None if timeout is None else time.time() + timeout 6050 req = SecretStoreDeleteRequest() 6051 6052 req.id = (id) 6053 tries = 0 6054 plumbing_response = None 6055 while True: 6056 t = None if deadline is None else deadline - time.time() 6057 try: 6058 plumbing_response = self.stub.Delete( 6059 req, 6060 metadata=self.parent.get_metadata('SecretStores.Delete', 6061 req), 6062 timeout=t) 6063 except Exception as e: 6064 if self.parent.shouldRetry(tries, e, deadline): 6065 tries += 1 6066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6067 continue 6068 raise plumbing.convert_error_to_porcelain(e) from e 6069 break 6070 6071 resp = models.SecretStoreDeleteResponse() 6072 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6073 plumbing_response.meta) 6074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6075 plumbing_response.rate_limit) 6076 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6078 def list(self, filter, *args, timeout=None): 6079 ''' 6080 List gets a list of SecretStores matching a given set of criteria. 6081 ''' 6082 deadline = None if timeout is None else time.time() + timeout 6083 req = SecretStoreListRequest() 6084 req.meta.CopyFrom(ListRequestMetadata()) 6085 if self.parent.page_limit > 0: 6086 req.meta.limit = self.parent.page_limit 6087 if self.parent.snapshot_datetime is not None: 6088 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6089 6090 req.filter = plumbing.quote_filter_args(filter, *args) 6091 6092 def generator(svc, req): 6093 tries = 0 6094 while True: 6095 t = None if deadline is None else deadline - time.time() 6096 try: 6097 plumbing_response = svc.stub.List( 6098 req, 6099 metadata=svc.parent.get_metadata( 6100 'SecretStores.List', req), 6101 timeout=t) 6102 except Exception as e: 6103 if self.parent.shouldRetry(tries, e, deadline): 6104 tries += 1 6105 time.sleep( 6106 self.parent.exponentialBackoff(tries, deadline)) 6107 continue 6108 raise plumbing.convert_error_to_porcelain(e) from e 6109 tries = 0 6110 for plumbing_item in plumbing_response.secret_stores: 6111 yield plumbing.convert_secret_store_to_porcelain( 6112 plumbing_item) 6113 if plumbing_response.meta.next_cursor == '': 6114 break 6115 req.meta.cursor = plumbing_response.meta.next_cursor 6116 6117 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
6120class SnapshotSecretStores: 6121 ''' 6122 SnapshotSecretStores exposes the read only methods of the SecretStores 6123 service for historical queries. 6124 ''' 6125 def __init__(self, secret_stores): 6126 self.secret_stores = secret_stores 6127 6128 def get(self, id, timeout=None): 6129 ''' 6130 Get reads one SecretStore by ID. 6131 ''' 6132 return self.secret_stores.get(id, timeout=timeout) 6133 6134 def list(self, filter, *args, timeout=None): 6135 ''' 6136 List gets a list of SecretStores matching a given set of criteria. 6137 ''' 6138 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)
6128 def get(self, id, timeout=None): 6129 ''' 6130 Get reads one SecretStore by ID. 6131 ''' 6132 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6134 def list(self, filter, *args, timeout=None): 6135 ''' 6136 List gets a list of SecretStores matching a given set of criteria. 6137 ''' 6138 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
6141class SecretEngines: 6142 ''' 6143 6144 See: 6145 `strongdm.models.ActiveDirectoryEngine` 6146 `strongdm.models.KeyValueEngine` 6147 ''' 6148 def __init__(self, channel, client): 6149 self.parent = client 6150 self.stub = SecretEnginesStub(channel) 6151 6152 def list(self, filter, *args, timeout=None): 6153 ''' 6154 List returns a list of Secret Engines 6155 ''' 6156 deadline = None if timeout is None else time.time() + timeout 6157 req = SecretEngineListRequest() 6158 req.meta.CopyFrom(ListRequestMetadata()) 6159 if self.parent.page_limit > 0: 6160 req.meta.limit = self.parent.page_limit 6161 if self.parent.snapshot_datetime is not None: 6162 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6163 6164 req.filter = plumbing.quote_filter_args(filter, *args) 6165 6166 def generator(svc, req): 6167 tries = 0 6168 while True: 6169 t = None if deadline is None else deadline - time.time() 6170 try: 6171 plumbing_response = svc.stub.List( 6172 req, 6173 metadata=svc.parent.get_metadata( 6174 'SecretEngines.List', req), 6175 timeout=t) 6176 except Exception as e: 6177 if self.parent.shouldRetry(tries, e, deadline): 6178 tries += 1 6179 time.sleep( 6180 self.parent.exponentialBackoff(tries, deadline)) 6181 continue 6182 raise plumbing.convert_error_to_porcelain(e) from e 6183 tries = 0 6184 for plumbing_item in plumbing_response.secret_engines: 6185 yield plumbing.convert_secret_engine_to_porcelain( 6186 plumbing_item) 6187 if plumbing_response.meta.next_cursor == '': 6188 break 6189 req.meta.cursor = plumbing_response.meta.next_cursor 6190 6191 return generator(self, req) 6192 6193 def get(self, id, timeout=None): 6194 ''' 6195 Get returns a secret engine details 6196 ''' 6197 deadline = None if timeout is None else time.time() + timeout 6198 req = SecretEngineGetRequest() 6199 if self.parent.snapshot_datetime is not None: 6200 req.meta.CopyFrom(GetRequestMetadata()) 6201 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6202 6203 req.id = (id) 6204 tries = 0 6205 plumbing_response = None 6206 while True: 6207 t = None if deadline is None else deadline - time.time() 6208 try: 6209 plumbing_response = self.stub.Get( 6210 req, 6211 metadata=self.parent.get_metadata('SecretEngines.Get', 6212 req), 6213 timeout=t) 6214 except Exception as e: 6215 if self.parent.shouldRetry(tries, e, deadline): 6216 tries += 1 6217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6218 continue 6219 raise plumbing.convert_error_to_porcelain(e) from e 6220 break 6221 6222 resp = models.SecretEngineGetResponse() 6223 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6224 plumbing_response.meta) 6225 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6226 plumbing_response.rate_limit) 6227 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6228 plumbing_response.secret_engine) 6229 return resp 6230 6231 def create(self, secret_engine, timeout=None): 6232 ''' 6233 Create creates a secret engine 6234 ''' 6235 deadline = None if timeout is None else time.time() + timeout 6236 req = SecretEngineCreateRequest() 6237 6238 if secret_engine is not None: 6239 req.secret_engine.CopyFrom( 6240 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6241 tries = 0 6242 plumbing_response = None 6243 while True: 6244 t = None if deadline is None else deadline - time.time() 6245 try: 6246 plumbing_response = self.stub.Create( 6247 req, 6248 metadata=self.parent.get_metadata('SecretEngines.Create', 6249 req), 6250 timeout=t) 6251 except Exception as e: 6252 if self.parent.shouldRetry(tries, e, deadline): 6253 tries += 1 6254 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6255 continue 6256 raise plumbing.convert_error_to_porcelain(e) from e 6257 break 6258 6259 resp = models.SecretEngineCreateResponse() 6260 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6261 plumbing_response.meta) 6262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6263 plumbing_response.rate_limit) 6264 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6265 plumbing_response.secret_engine) 6266 return resp 6267 6268 def update(self, secret_engine, timeout=None): 6269 ''' 6270 Update updates a secret engine 6271 ''' 6272 deadline = None if timeout is None else time.time() + timeout 6273 req = SecretEngineUpdateRequest() 6274 6275 if secret_engine is not None: 6276 req.secret_engine.CopyFrom( 6277 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6278 tries = 0 6279 plumbing_response = None 6280 while True: 6281 t = None if deadline is None else deadline - time.time() 6282 try: 6283 plumbing_response = self.stub.Update( 6284 req, 6285 metadata=self.parent.get_metadata('SecretEngines.Update', 6286 req), 6287 timeout=t) 6288 except Exception as e: 6289 if self.parent.shouldRetry(tries, e, deadline): 6290 tries += 1 6291 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6292 continue 6293 raise plumbing.convert_error_to_porcelain(e) from e 6294 break 6295 6296 resp = models.SecretEngineUpdateResponse() 6297 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6298 plumbing_response.meta) 6299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6300 plumbing_response.rate_limit) 6301 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6302 plumbing_response.secret_engine) 6303 return resp 6304 6305 def delete(self, id, timeout=None): 6306 ''' 6307 Delete deletes a secret engine 6308 ''' 6309 deadline = None if timeout is None else time.time() + timeout 6310 req = SecretEngineDeleteRequest() 6311 6312 req.id = (id) 6313 tries = 0 6314 plumbing_response = None 6315 while True: 6316 t = None if deadline is None else deadline - time.time() 6317 try: 6318 plumbing_response = self.stub.Delete( 6319 req, 6320 metadata=self.parent.get_metadata('SecretEngines.Delete', 6321 req), 6322 timeout=t) 6323 except Exception as e: 6324 if self.parent.shouldRetry(tries, e, deadline): 6325 tries += 1 6326 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6327 continue 6328 raise plumbing.convert_error_to_porcelain(e) from e 6329 break 6330 6331 resp = models.SecretEngineDeleteResponse() 6332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6333 plumbing_response.rate_limit) 6334 return resp 6335 6336 def list_secret_stores(self, filter, *args, timeout=None): 6337 ''' 6338 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6339 for Secret Engine 6340 ''' 6341 deadline = None if timeout is None else time.time() + timeout 6342 req = SecretStoreListRequest() 6343 req.meta.CopyFrom(ListRequestMetadata()) 6344 if self.parent.page_limit > 0: 6345 req.meta.limit = self.parent.page_limit 6346 if self.parent.snapshot_datetime is not None: 6347 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6348 6349 req.filter = plumbing.quote_filter_args(filter, *args) 6350 6351 def generator(svc, req): 6352 tries = 0 6353 while True: 6354 t = None if deadline is None else deadline - time.time() 6355 try: 6356 plumbing_response = svc.stub.ListSecretStores( 6357 req, 6358 metadata=svc.parent.get_metadata( 6359 'SecretEngines.ListSecretStores', req), 6360 timeout=t) 6361 except Exception as e: 6362 if self.parent.shouldRetry(tries, e, deadline): 6363 tries += 1 6364 time.sleep( 6365 self.parent.exponentialBackoff(tries, deadline)) 6366 continue 6367 raise plumbing.convert_error_to_porcelain(e) from e 6368 tries = 0 6369 for plumbing_item in plumbing_response.secret_stores: 6370 yield plumbing.convert_secret_store_to_porcelain( 6371 plumbing_item) 6372 if plumbing_response.meta.next_cursor == '': 6373 break 6374 req.meta.cursor = plumbing_response.meta.next_cursor 6375 6376 return generator(self, req) 6377 6378 def generate_keys(self, secret_engine_id, timeout=None): 6379 ''' 6380 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6381 ''' 6382 deadline = None if timeout is None else time.time() + timeout 6383 req = GenerateKeysRequest() 6384 6385 req.secret_engine_id = (secret_engine_id) 6386 tries = 0 6387 plumbing_response = None 6388 while True: 6389 t = None if deadline is None else deadline - time.time() 6390 try: 6391 plumbing_response = self.stub.GenerateKeys( 6392 req, 6393 metadata=self.parent.get_metadata( 6394 'SecretEngines.GenerateKeys', req), 6395 timeout=t) 6396 except Exception as e: 6397 if self.parent.shouldRetry(tries, e, deadline): 6398 tries += 1 6399 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6400 continue 6401 raise plumbing.convert_error_to_porcelain(e) from e 6402 break 6403 6404 resp = models.GenerateKeysResponse() 6405 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6406 plumbing_response.rate_limit) 6407 return resp 6408 6409 def healthcheck(self, secret_engine_id, timeout=None): 6410 ''' 6411 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6412 ''' 6413 deadline = None if timeout is None else time.time() + timeout 6414 req = HealthcheckRequest() 6415 6416 req.secret_engine_id = (secret_engine_id) 6417 tries = 0 6418 plumbing_response = None 6419 while True: 6420 t = None if deadline is None else deadline - time.time() 6421 try: 6422 plumbing_response = self.stub.Healthcheck( 6423 req, 6424 metadata=self.parent.get_metadata( 6425 'SecretEngines.Healthcheck', req), 6426 timeout=t) 6427 except Exception as e: 6428 if self.parent.shouldRetry(tries, e, deadline): 6429 tries += 1 6430 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6431 continue 6432 raise plumbing.convert_error_to_porcelain(e) from e 6433 break 6434 6435 resp = models.HealthcheckResponse() 6436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6437 plumbing_response.rate_limit) 6438 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6439 plumbing_response.status) 6440 return resp 6441 6442 def rotate(self, id, password_policy, timeout=None): 6443 ''' 6444 Rotate rotates secret engine's credentials 6445 ''' 6446 deadline = None if timeout is None else time.time() + timeout 6447 req = SecretEngineRotateRequest() 6448 6449 req.id = (id) 6450 if password_policy is not None: 6451 req.password_policy.CopyFrom( 6452 plumbing.convert_secret_engine_password_policy_to_plumbing( 6453 password_policy)) 6454 tries = 0 6455 plumbing_response = None 6456 while True: 6457 t = None if deadline is None else deadline - time.time() 6458 try: 6459 plumbing_response = self.stub.Rotate( 6460 req, 6461 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6462 req), 6463 timeout=t) 6464 except Exception as e: 6465 if self.parent.shouldRetry(tries, e, deadline): 6466 tries += 1 6467 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6468 continue 6469 raise plumbing.convert_error_to_porcelain(e) from e 6470 break 6471 6472 resp = models.SecretEngineRotateResponse() 6473 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6474 plumbing_response.rate_limit) 6475 return resp
def
list(self, filter, *args, timeout=None)
6152 def list(self, filter, *args, timeout=None): 6153 ''' 6154 List returns a list of Secret Engines 6155 ''' 6156 deadline = None if timeout is None else time.time() + timeout 6157 req = SecretEngineListRequest() 6158 req.meta.CopyFrom(ListRequestMetadata()) 6159 if self.parent.page_limit > 0: 6160 req.meta.limit = self.parent.page_limit 6161 if self.parent.snapshot_datetime is not None: 6162 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6163 6164 req.filter = plumbing.quote_filter_args(filter, *args) 6165 6166 def generator(svc, req): 6167 tries = 0 6168 while True: 6169 t = None if deadline is None else deadline - time.time() 6170 try: 6171 plumbing_response = svc.stub.List( 6172 req, 6173 metadata=svc.parent.get_metadata( 6174 'SecretEngines.List', req), 6175 timeout=t) 6176 except Exception as e: 6177 if self.parent.shouldRetry(tries, e, deadline): 6178 tries += 1 6179 time.sleep( 6180 self.parent.exponentialBackoff(tries, deadline)) 6181 continue 6182 raise plumbing.convert_error_to_porcelain(e) from e 6183 tries = 0 6184 for plumbing_item in plumbing_response.secret_engines: 6185 yield plumbing.convert_secret_engine_to_porcelain( 6186 plumbing_item) 6187 if plumbing_response.meta.next_cursor == '': 6188 break 6189 req.meta.cursor = plumbing_response.meta.next_cursor 6190 6191 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
6193 def get(self, id, timeout=None): 6194 ''' 6195 Get returns a secret engine details 6196 ''' 6197 deadline = None if timeout is None else time.time() + timeout 6198 req = SecretEngineGetRequest() 6199 if self.parent.snapshot_datetime is not None: 6200 req.meta.CopyFrom(GetRequestMetadata()) 6201 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6202 6203 req.id = (id) 6204 tries = 0 6205 plumbing_response = None 6206 while True: 6207 t = None if deadline is None else deadline - time.time() 6208 try: 6209 plumbing_response = self.stub.Get( 6210 req, 6211 metadata=self.parent.get_metadata('SecretEngines.Get', 6212 req), 6213 timeout=t) 6214 except Exception as e: 6215 if self.parent.shouldRetry(tries, e, deadline): 6216 tries += 1 6217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6218 continue 6219 raise plumbing.convert_error_to_porcelain(e) from e 6220 break 6221 6222 resp = models.SecretEngineGetResponse() 6223 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6224 plumbing_response.meta) 6225 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6226 plumbing_response.rate_limit) 6227 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6228 plumbing_response.secret_engine) 6229 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
6231 def create(self, secret_engine, timeout=None): 6232 ''' 6233 Create creates a secret engine 6234 ''' 6235 deadline = None if timeout is None else time.time() + timeout 6236 req = SecretEngineCreateRequest() 6237 6238 if secret_engine is not None: 6239 req.secret_engine.CopyFrom( 6240 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6241 tries = 0 6242 plumbing_response = None 6243 while True: 6244 t = None if deadline is None else deadline - time.time() 6245 try: 6246 plumbing_response = self.stub.Create( 6247 req, 6248 metadata=self.parent.get_metadata('SecretEngines.Create', 6249 req), 6250 timeout=t) 6251 except Exception as e: 6252 if self.parent.shouldRetry(tries, e, deadline): 6253 tries += 1 6254 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6255 continue 6256 raise plumbing.convert_error_to_porcelain(e) from e 6257 break 6258 6259 resp = models.SecretEngineCreateResponse() 6260 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6261 plumbing_response.meta) 6262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6263 plumbing_response.rate_limit) 6264 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6265 plumbing_response.secret_engine) 6266 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
6268 def update(self, secret_engine, timeout=None): 6269 ''' 6270 Update updates a secret engine 6271 ''' 6272 deadline = None if timeout is None else time.time() + timeout 6273 req = SecretEngineUpdateRequest() 6274 6275 if secret_engine is not None: 6276 req.secret_engine.CopyFrom( 6277 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 6278 tries = 0 6279 plumbing_response = None 6280 while True: 6281 t = None if deadline is None else deadline - time.time() 6282 try: 6283 plumbing_response = self.stub.Update( 6284 req, 6285 metadata=self.parent.get_metadata('SecretEngines.Update', 6286 req), 6287 timeout=t) 6288 except Exception as e: 6289 if self.parent.shouldRetry(tries, e, deadline): 6290 tries += 1 6291 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6292 continue 6293 raise plumbing.convert_error_to_porcelain(e) from e 6294 break 6295 6296 resp = models.SecretEngineUpdateResponse() 6297 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6298 plumbing_response.meta) 6299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6300 plumbing_response.rate_limit) 6301 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 6302 plumbing_response.secret_engine) 6303 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
6305 def delete(self, id, timeout=None): 6306 ''' 6307 Delete deletes a secret engine 6308 ''' 6309 deadline = None if timeout is None else time.time() + timeout 6310 req = SecretEngineDeleteRequest() 6311 6312 req.id = (id) 6313 tries = 0 6314 plumbing_response = None 6315 while True: 6316 t = None if deadline is None else deadline - time.time() 6317 try: 6318 plumbing_response = self.stub.Delete( 6319 req, 6320 metadata=self.parent.get_metadata('SecretEngines.Delete', 6321 req), 6322 timeout=t) 6323 except Exception as e: 6324 if self.parent.shouldRetry(tries, e, deadline): 6325 tries += 1 6326 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6327 continue 6328 raise plumbing.convert_error_to_porcelain(e) from e 6329 break 6330 6331 resp = models.SecretEngineDeleteResponse() 6332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6333 plumbing_response.rate_limit) 6334 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
6336 def list_secret_stores(self, filter, *args, timeout=None): 6337 ''' 6338 ListSecretStores returns a list of Secret Stores that can be used as a backing store 6339 for Secret Engine 6340 ''' 6341 deadline = None if timeout is None else time.time() + timeout 6342 req = SecretStoreListRequest() 6343 req.meta.CopyFrom(ListRequestMetadata()) 6344 if self.parent.page_limit > 0: 6345 req.meta.limit = self.parent.page_limit 6346 if self.parent.snapshot_datetime is not None: 6347 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6348 6349 req.filter = plumbing.quote_filter_args(filter, *args) 6350 6351 def generator(svc, req): 6352 tries = 0 6353 while True: 6354 t = None if deadline is None else deadline - time.time() 6355 try: 6356 plumbing_response = svc.stub.ListSecretStores( 6357 req, 6358 metadata=svc.parent.get_metadata( 6359 'SecretEngines.ListSecretStores', req), 6360 timeout=t) 6361 except Exception as e: 6362 if self.parent.shouldRetry(tries, e, deadline): 6363 tries += 1 6364 time.sleep( 6365 self.parent.exponentialBackoff(tries, deadline)) 6366 continue 6367 raise plumbing.convert_error_to_porcelain(e) from e 6368 tries = 0 6369 for plumbing_item in plumbing_response.secret_stores: 6370 yield plumbing.convert_secret_store_to_porcelain( 6371 plumbing_item) 6372 if plumbing_response.meta.next_cursor == '': 6373 break 6374 req.meta.cursor = plumbing_response.meta.next_cursor 6375 6376 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)
6378 def generate_keys(self, secret_engine_id, timeout=None): 6379 ''' 6380 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 6381 ''' 6382 deadline = None if timeout is None else time.time() + timeout 6383 req = GenerateKeysRequest() 6384 6385 req.secret_engine_id = (secret_engine_id) 6386 tries = 0 6387 plumbing_response = None 6388 while True: 6389 t = None if deadline is None else deadline - time.time() 6390 try: 6391 plumbing_response = self.stub.GenerateKeys( 6392 req, 6393 metadata=self.parent.get_metadata( 6394 'SecretEngines.GenerateKeys', req), 6395 timeout=t) 6396 except Exception as e: 6397 if self.parent.shouldRetry(tries, e, deadline): 6398 tries += 1 6399 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6400 continue 6401 raise plumbing.convert_error_to_porcelain(e) from e 6402 break 6403 6404 resp = models.GenerateKeysResponse() 6405 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6406 plumbing_response.rate_limit) 6407 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)
6409 def healthcheck(self, secret_engine_id, timeout=None): 6410 ''' 6411 Healthcheck triggers a healthcheck for all nodes serving a secret engine 6412 ''' 6413 deadline = None if timeout is None else time.time() + timeout 6414 req = HealthcheckRequest() 6415 6416 req.secret_engine_id = (secret_engine_id) 6417 tries = 0 6418 plumbing_response = None 6419 while True: 6420 t = None if deadline is None else deadline - time.time() 6421 try: 6422 plumbing_response = self.stub.Healthcheck( 6423 req, 6424 metadata=self.parent.get_metadata( 6425 'SecretEngines.Healthcheck', req), 6426 timeout=t) 6427 except Exception as e: 6428 if self.parent.shouldRetry(tries, e, deadline): 6429 tries += 1 6430 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6431 continue 6432 raise plumbing.convert_error_to_porcelain(e) from e 6433 break 6434 6435 resp = models.HealthcheckResponse() 6436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6437 plumbing_response.rate_limit) 6438 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 6439 plumbing_response.status) 6440 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
6442 def rotate(self, id, password_policy, timeout=None): 6443 ''' 6444 Rotate rotates secret engine's credentials 6445 ''' 6446 deadline = None if timeout is None else time.time() + timeout 6447 req = SecretEngineRotateRequest() 6448 6449 req.id = (id) 6450 if password_policy is not None: 6451 req.password_policy.CopyFrom( 6452 plumbing.convert_secret_engine_password_policy_to_plumbing( 6453 password_policy)) 6454 tries = 0 6455 plumbing_response = None 6456 while True: 6457 t = None if deadline is None else deadline - time.time() 6458 try: 6459 plumbing_response = self.stub.Rotate( 6460 req, 6461 metadata=self.parent.get_metadata('SecretEngines.Rotate', 6462 req), 6463 timeout=t) 6464 except Exception as e: 6465 if self.parent.shouldRetry(tries, e, deadline): 6466 tries += 1 6467 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6468 continue 6469 raise plumbing.convert_error_to_porcelain(e) from e 6470 break 6471 6472 resp = models.SecretEngineRotateResponse() 6473 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6474 plumbing_response.rate_limit) 6475 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
6478class SecretStoreHealths: 6479 ''' 6480 SecretStoreHealths exposes health states for secret stores. 6481 See `strongdm.models.SecretStoreHealth`. 6482 ''' 6483 def __init__(self, channel, client): 6484 self.parent = client 6485 self.stub = SecretStoreHealthsStub(channel) 6486 6487 def list(self, filter, *args, timeout=None): 6488 ''' 6489 List reports the health status of node to secret store pairs. 6490 ''' 6491 deadline = None if timeout is None else time.time() + timeout 6492 req = SecretStoreHealthListRequest() 6493 req.meta.CopyFrom(ListRequestMetadata()) 6494 if self.parent.page_limit > 0: 6495 req.meta.limit = self.parent.page_limit 6496 if self.parent.snapshot_datetime is not None: 6497 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6498 6499 req.filter = plumbing.quote_filter_args(filter, *args) 6500 6501 def generator(svc, req): 6502 tries = 0 6503 while True: 6504 t = None if deadline is None else deadline - time.time() 6505 try: 6506 plumbing_response = svc.stub.List( 6507 req, 6508 metadata=svc.parent.get_metadata( 6509 'SecretStoreHealths.List', req), 6510 timeout=t) 6511 except Exception as e: 6512 if self.parent.shouldRetry(tries, e, deadline): 6513 tries += 1 6514 time.sleep( 6515 self.parent.exponentialBackoff(tries, deadline)) 6516 continue 6517 raise plumbing.convert_error_to_porcelain(e) from e 6518 tries = 0 6519 for plumbing_item in plumbing_response.secret_store_healths: 6520 yield plumbing.convert_secret_store_health_to_porcelain( 6521 plumbing_item) 6522 if plumbing_response.meta.next_cursor == '': 6523 break 6524 req.meta.cursor = plumbing_response.meta.next_cursor 6525 6526 return generator(self, req) 6527 6528 def healthcheck(self, secret_store_id, timeout=None): 6529 ''' 6530 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6531 to propagate across a large network of Nodes. The call will return immediately, and the 6532 updated health of the Secret Store can be retrieved via List. 6533 ''' 6534 deadline = None if timeout is None else time.time() + timeout 6535 req = SecretStoreHealthcheckRequest() 6536 6537 req.secret_store_id = (secret_store_id) 6538 tries = 0 6539 plumbing_response = None 6540 while True: 6541 t = None if deadline is None else deadline - time.time() 6542 try: 6543 plumbing_response = self.stub.Healthcheck( 6544 req, 6545 metadata=self.parent.get_metadata( 6546 'SecretStoreHealths.Healthcheck', req), 6547 timeout=t) 6548 except Exception as e: 6549 if self.parent.shouldRetry(tries, e, deadline): 6550 tries += 1 6551 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6552 continue 6553 raise plumbing.convert_error_to_porcelain(e) from e 6554 break 6555 6556 resp = models.SecretStoreHealthcheckResponse() 6557 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6558 plumbing_response.rate_limit) 6559 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
6487 def list(self, filter, *args, timeout=None): 6488 ''' 6489 List reports the health status of node to secret store pairs. 6490 ''' 6491 deadline = None if timeout is None else time.time() + timeout 6492 req = SecretStoreHealthListRequest() 6493 req.meta.CopyFrom(ListRequestMetadata()) 6494 if self.parent.page_limit > 0: 6495 req.meta.limit = self.parent.page_limit 6496 if self.parent.snapshot_datetime is not None: 6497 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6498 6499 req.filter = plumbing.quote_filter_args(filter, *args) 6500 6501 def generator(svc, req): 6502 tries = 0 6503 while True: 6504 t = None if deadline is None else deadline - time.time() 6505 try: 6506 plumbing_response = svc.stub.List( 6507 req, 6508 metadata=svc.parent.get_metadata( 6509 'SecretStoreHealths.List', req), 6510 timeout=t) 6511 except Exception as e: 6512 if self.parent.shouldRetry(tries, e, deadline): 6513 tries += 1 6514 time.sleep( 6515 self.parent.exponentialBackoff(tries, deadline)) 6516 continue 6517 raise plumbing.convert_error_to_porcelain(e) from e 6518 tries = 0 6519 for plumbing_item in plumbing_response.secret_store_healths: 6520 yield plumbing.convert_secret_store_health_to_porcelain( 6521 plumbing_item) 6522 if plumbing_response.meta.next_cursor == '': 6523 break 6524 req.meta.cursor = plumbing_response.meta.next_cursor 6525 6526 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
6528 def healthcheck(self, secret_store_id, timeout=None): 6529 ''' 6530 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 6531 to propagate across a large network of Nodes. The call will return immediately, and the 6532 updated health of the Secret Store can be retrieved via List. 6533 ''' 6534 deadline = None if timeout is None else time.time() + timeout 6535 req = SecretStoreHealthcheckRequest() 6536 6537 req.secret_store_id = (secret_store_id) 6538 tries = 0 6539 plumbing_response = None 6540 while True: 6541 t = None if deadline is None else deadline - time.time() 6542 try: 6543 plumbing_response = self.stub.Healthcheck( 6544 req, 6545 metadata=self.parent.get_metadata( 6546 'SecretStoreHealths.Healthcheck', req), 6547 timeout=t) 6548 except Exception as e: 6549 if self.parent.shouldRetry(tries, e, deadline): 6550 tries += 1 6551 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6552 continue 6553 raise plumbing.convert_error_to_porcelain(e) from e 6554 break 6555 6556 resp = models.SecretStoreHealthcheckResponse() 6557 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6558 plumbing_response.rate_limit) 6559 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:
6562class SecretStoresHistory: 6563 ''' 6564 SecretStoresHistory records all changes to the state of a SecretStore. 6565 See `strongdm.models.SecretStoreHistory`. 6566 ''' 6567 def __init__(self, channel, client): 6568 self.parent = client 6569 self.stub = SecretStoresHistoryStub(channel) 6570 6571 def list(self, filter, *args, timeout=None): 6572 ''' 6573 List gets a list of SecretStoreHistory records matching a given set of criteria. 6574 ''' 6575 deadline = None if timeout is None else time.time() + timeout 6576 req = SecretStoreHistoryListRequest() 6577 req.meta.CopyFrom(ListRequestMetadata()) 6578 if self.parent.page_limit > 0: 6579 req.meta.limit = self.parent.page_limit 6580 if self.parent.snapshot_datetime is not None: 6581 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6582 6583 req.filter = plumbing.quote_filter_args(filter, *args) 6584 6585 def generator(svc, req): 6586 tries = 0 6587 while True: 6588 t = None if deadline is None else deadline - time.time() 6589 try: 6590 plumbing_response = svc.stub.List( 6591 req, 6592 metadata=svc.parent.get_metadata( 6593 'SecretStoresHistory.List', req), 6594 timeout=t) 6595 except Exception as e: 6596 if self.parent.shouldRetry(tries, e, deadline): 6597 tries += 1 6598 time.sleep( 6599 self.parent.exponentialBackoff(tries, deadline)) 6600 continue 6601 raise plumbing.convert_error_to_porcelain(e) from e 6602 tries = 0 6603 for plumbing_item in plumbing_response.history: 6604 yield plumbing.convert_secret_store_history_to_porcelain( 6605 plumbing_item) 6606 if plumbing_response.meta.next_cursor == '': 6607 break 6608 req.meta.cursor = plumbing_response.meta.next_cursor 6609 6610 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)
6571 def list(self, filter, *args, timeout=None): 6572 ''' 6573 List gets a list of SecretStoreHistory records matching a given set of criteria. 6574 ''' 6575 deadline = None if timeout is None else time.time() + timeout 6576 req = SecretStoreHistoryListRequest() 6577 req.meta.CopyFrom(ListRequestMetadata()) 6578 if self.parent.page_limit > 0: 6579 req.meta.limit = self.parent.page_limit 6580 if self.parent.snapshot_datetime is not None: 6581 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6582 6583 req.filter = plumbing.quote_filter_args(filter, *args) 6584 6585 def generator(svc, req): 6586 tries = 0 6587 while True: 6588 t = None if deadline is None else deadline - time.time() 6589 try: 6590 plumbing_response = svc.stub.List( 6591 req, 6592 metadata=svc.parent.get_metadata( 6593 'SecretStoresHistory.List', req), 6594 timeout=t) 6595 except Exception as e: 6596 if self.parent.shouldRetry(tries, e, deadline): 6597 tries += 1 6598 time.sleep( 6599 self.parent.exponentialBackoff(tries, deadline)) 6600 continue 6601 raise plumbing.convert_error_to_porcelain(e) from e 6602 tries = 0 6603 for plumbing_item in plumbing_response.history: 6604 yield plumbing.convert_secret_store_history_to_porcelain( 6605 plumbing_item) 6606 if plumbing_response.meta.next_cursor == '': 6607 break 6608 req.meta.cursor = plumbing_response.meta.next_cursor 6609 6610 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
6613class WorkflowApprovers: 6614 ''' 6615 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 6616 See `strongdm.models.WorkflowApprover`. 6617 ''' 6618 def __init__(self, channel, client): 6619 self.parent = client 6620 self.stub = WorkflowApproversStub(channel) 6621 6622 def create(self, workflow_approver, timeout=None): 6623 ''' 6624 Create creates a new workflow approver 6625 ''' 6626 deadline = None if timeout is None else time.time() + timeout 6627 req = WorkflowApproversCreateRequest() 6628 6629 if workflow_approver is not None: 6630 req.workflow_approver.CopyFrom( 6631 plumbing.convert_workflow_approver_to_plumbing( 6632 workflow_approver)) 6633 tries = 0 6634 plumbing_response = None 6635 while True: 6636 t = None if deadline is None else deadline - time.time() 6637 try: 6638 plumbing_response = self.stub.Create( 6639 req, 6640 metadata=self.parent.get_metadata( 6641 'WorkflowApprovers.Create', req), 6642 timeout=t) 6643 except Exception as e: 6644 if self.parent.shouldRetry(tries, e, deadline): 6645 tries += 1 6646 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6647 continue 6648 raise plumbing.convert_error_to_porcelain(e) from e 6649 break 6650 6651 resp = models.WorkflowApproversCreateResponse() 6652 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6653 plumbing_response.rate_limit) 6654 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6655 plumbing_response.workflow_approver) 6656 return resp 6657 6658 def get(self, id, timeout=None): 6659 ''' 6660 Get reads one workflow approver by ID. 6661 ''' 6662 deadline = None if timeout is None else time.time() + timeout 6663 req = WorkflowApproverGetRequest() 6664 if self.parent.snapshot_datetime is not None: 6665 req.meta.CopyFrom(GetRequestMetadata()) 6666 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6667 6668 req.id = (id) 6669 tries = 0 6670 plumbing_response = None 6671 while True: 6672 t = None if deadline is None else deadline - time.time() 6673 try: 6674 plumbing_response = self.stub.Get( 6675 req, 6676 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6677 req), 6678 timeout=t) 6679 except Exception as e: 6680 if self.parent.shouldRetry(tries, e, deadline): 6681 tries += 1 6682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6683 continue 6684 raise plumbing.convert_error_to_porcelain(e) from e 6685 break 6686 6687 resp = models.WorkflowApproverGetResponse() 6688 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6689 plumbing_response.meta) 6690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6691 plumbing_response.rate_limit) 6692 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6693 plumbing_response.workflow_approver) 6694 return resp 6695 6696 def delete(self, id, timeout=None): 6697 ''' 6698 Delete deletes a workflow approver 6699 ''' 6700 deadline = None if timeout is None else time.time() + timeout 6701 req = WorkflowApproversDeleteRequest() 6702 6703 req.id = (id) 6704 tries = 0 6705 plumbing_response = None 6706 while True: 6707 t = None if deadline is None else deadline - time.time() 6708 try: 6709 plumbing_response = self.stub.Delete( 6710 req, 6711 metadata=self.parent.get_metadata( 6712 'WorkflowApprovers.Delete', req), 6713 timeout=t) 6714 except Exception as e: 6715 if self.parent.shouldRetry(tries, e, deadline): 6716 tries += 1 6717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6718 continue 6719 raise plumbing.convert_error_to_porcelain(e) from e 6720 break 6721 6722 resp = models.WorkflowApproversDeleteResponse() 6723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6724 plumbing_response.rate_limit) 6725 return resp 6726 6727 def list(self, filter, *args, timeout=None): 6728 ''' 6729 Lists existing workflow approvers. 6730 ''' 6731 deadline = None if timeout is None else time.time() + timeout 6732 req = WorkflowApproversListRequest() 6733 req.meta.CopyFrom(ListRequestMetadata()) 6734 if self.parent.page_limit > 0: 6735 req.meta.limit = self.parent.page_limit 6736 if self.parent.snapshot_datetime is not None: 6737 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6738 6739 req.filter = plumbing.quote_filter_args(filter, *args) 6740 6741 def generator(svc, req): 6742 tries = 0 6743 while True: 6744 t = None if deadline is None else deadline - time.time() 6745 try: 6746 plumbing_response = svc.stub.List( 6747 req, 6748 metadata=svc.parent.get_metadata( 6749 'WorkflowApprovers.List', req), 6750 timeout=t) 6751 except Exception as e: 6752 if self.parent.shouldRetry(tries, e, deadline): 6753 tries += 1 6754 time.sleep( 6755 self.parent.exponentialBackoff(tries, deadline)) 6756 continue 6757 raise plumbing.convert_error_to_porcelain(e) from e 6758 tries = 0 6759 for plumbing_item in plumbing_response.workflow_approvers: 6760 yield plumbing.convert_workflow_approver_to_porcelain( 6761 plumbing_item) 6762 if plumbing_response.meta.next_cursor == '': 6763 break 6764 req.meta.cursor = plumbing_response.meta.next_cursor 6765 6766 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)
6622 def create(self, workflow_approver, timeout=None): 6623 ''' 6624 Create creates a new workflow approver 6625 ''' 6626 deadline = None if timeout is None else time.time() + timeout 6627 req = WorkflowApproversCreateRequest() 6628 6629 if workflow_approver is not None: 6630 req.workflow_approver.CopyFrom( 6631 plumbing.convert_workflow_approver_to_plumbing( 6632 workflow_approver)) 6633 tries = 0 6634 plumbing_response = None 6635 while True: 6636 t = None if deadline is None else deadline - time.time() 6637 try: 6638 plumbing_response = self.stub.Create( 6639 req, 6640 metadata=self.parent.get_metadata( 6641 'WorkflowApprovers.Create', req), 6642 timeout=t) 6643 except Exception as e: 6644 if self.parent.shouldRetry(tries, e, deadline): 6645 tries += 1 6646 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6647 continue 6648 raise plumbing.convert_error_to_porcelain(e) from e 6649 break 6650 6651 resp = models.WorkflowApproversCreateResponse() 6652 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6653 plumbing_response.rate_limit) 6654 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6655 plumbing_response.workflow_approver) 6656 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
6658 def get(self, id, timeout=None): 6659 ''' 6660 Get reads one workflow approver by ID. 6661 ''' 6662 deadline = None if timeout is None else time.time() + timeout 6663 req = WorkflowApproverGetRequest() 6664 if self.parent.snapshot_datetime is not None: 6665 req.meta.CopyFrom(GetRequestMetadata()) 6666 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6667 6668 req.id = (id) 6669 tries = 0 6670 plumbing_response = None 6671 while True: 6672 t = None if deadline is None else deadline - time.time() 6673 try: 6674 plumbing_response = self.stub.Get( 6675 req, 6676 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 6677 req), 6678 timeout=t) 6679 except Exception as e: 6680 if self.parent.shouldRetry(tries, e, deadline): 6681 tries += 1 6682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6683 continue 6684 raise plumbing.convert_error_to_porcelain(e) from e 6685 break 6686 6687 resp = models.WorkflowApproverGetResponse() 6688 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6689 plumbing_response.meta) 6690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6691 plumbing_response.rate_limit) 6692 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 6693 plumbing_response.workflow_approver) 6694 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
6696 def delete(self, id, timeout=None): 6697 ''' 6698 Delete deletes a workflow approver 6699 ''' 6700 deadline = None if timeout is None else time.time() + timeout 6701 req = WorkflowApproversDeleteRequest() 6702 6703 req.id = (id) 6704 tries = 0 6705 plumbing_response = None 6706 while True: 6707 t = None if deadline is None else deadline - time.time() 6708 try: 6709 plumbing_response = self.stub.Delete( 6710 req, 6711 metadata=self.parent.get_metadata( 6712 'WorkflowApprovers.Delete', req), 6713 timeout=t) 6714 except Exception as e: 6715 if self.parent.shouldRetry(tries, e, deadline): 6716 tries += 1 6717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6718 continue 6719 raise plumbing.convert_error_to_porcelain(e) from e 6720 break 6721 6722 resp = models.WorkflowApproversDeleteResponse() 6723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6724 plumbing_response.rate_limit) 6725 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
6727 def list(self, filter, *args, timeout=None): 6728 ''' 6729 Lists existing workflow approvers. 6730 ''' 6731 deadline = None if timeout is None else time.time() + timeout 6732 req = WorkflowApproversListRequest() 6733 req.meta.CopyFrom(ListRequestMetadata()) 6734 if self.parent.page_limit > 0: 6735 req.meta.limit = self.parent.page_limit 6736 if self.parent.snapshot_datetime is not None: 6737 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6738 6739 req.filter = plumbing.quote_filter_args(filter, *args) 6740 6741 def generator(svc, req): 6742 tries = 0 6743 while True: 6744 t = None if deadline is None else deadline - time.time() 6745 try: 6746 plumbing_response = svc.stub.List( 6747 req, 6748 metadata=svc.parent.get_metadata( 6749 'WorkflowApprovers.List', req), 6750 timeout=t) 6751 except Exception as e: 6752 if self.parent.shouldRetry(tries, e, deadline): 6753 tries += 1 6754 time.sleep( 6755 self.parent.exponentialBackoff(tries, deadline)) 6756 continue 6757 raise plumbing.convert_error_to_porcelain(e) from e 6758 tries = 0 6759 for plumbing_item in plumbing_response.workflow_approvers: 6760 yield plumbing.convert_workflow_approver_to_porcelain( 6761 plumbing_item) 6762 if plumbing_response.meta.next_cursor == '': 6763 break 6764 req.meta.cursor = plumbing_response.meta.next_cursor 6765 6766 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
6769class SnapshotWorkflowApprovers: 6770 ''' 6771 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 6772 service for historical queries. 6773 ''' 6774 def __init__(self, workflow_approvers): 6775 self.workflow_approvers = workflow_approvers 6776 6777 def get(self, id, timeout=None): 6778 ''' 6779 Get reads one workflow approver by ID. 6780 ''' 6781 return self.workflow_approvers.get(id, timeout=timeout) 6782 6783 def list(self, filter, *args, timeout=None): 6784 ''' 6785 Lists existing workflow approvers. 6786 ''' 6787 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
6790class WorkflowApproversHistory: 6791 ''' 6792 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 6793 See `strongdm.models.WorkflowApproverHistory`. 6794 ''' 6795 def __init__(self, channel, client): 6796 self.parent = client 6797 self.stub = WorkflowApproversHistoryStub(channel) 6798 6799 def list(self, filter, *args, timeout=None): 6800 ''' 6801 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6802 ''' 6803 deadline = None if timeout is None else time.time() + timeout 6804 req = WorkflowApproversHistoryListRequest() 6805 req.meta.CopyFrom(ListRequestMetadata()) 6806 if self.parent.page_limit > 0: 6807 req.meta.limit = self.parent.page_limit 6808 if self.parent.snapshot_datetime is not None: 6809 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6810 6811 req.filter = plumbing.quote_filter_args(filter, *args) 6812 6813 def generator(svc, req): 6814 tries = 0 6815 while True: 6816 t = None if deadline is None else deadline - time.time() 6817 try: 6818 plumbing_response = svc.stub.List( 6819 req, 6820 metadata=svc.parent.get_metadata( 6821 'WorkflowApproversHistory.List', req), 6822 timeout=t) 6823 except Exception as e: 6824 if self.parent.shouldRetry(tries, e, deadline): 6825 tries += 1 6826 time.sleep( 6827 self.parent.exponentialBackoff(tries, deadline)) 6828 continue 6829 raise plumbing.convert_error_to_porcelain(e) from e 6830 tries = 0 6831 for plumbing_item in plumbing_response.history: 6832 yield plumbing.convert_workflow_approver_history_to_porcelain( 6833 plumbing_item) 6834 if plumbing_response.meta.next_cursor == '': 6835 break 6836 req.meta.cursor = plumbing_response.meta.next_cursor 6837 6838 return generator(self, req)
WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover.
See strongdm.models.WorkflowApproverHistory.
def
list(self, filter, *args, timeout=None)
6799 def list(self, filter, *args, timeout=None): 6800 ''' 6801 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 6802 ''' 6803 deadline = None if timeout is None else time.time() + timeout 6804 req = WorkflowApproversHistoryListRequest() 6805 req.meta.CopyFrom(ListRequestMetadata()) 6806 if self.parent.page_limit > 0: 6807 req.meta.limit = self.parent.page_limit 6808 if self.parent.snapshot_datetime is not None: 6809 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6810 6811 req.filter = plumbing.quote_filter_args(filter, *args) 6812 6813 def generator(svc, req): 6814 tries = 0 6815 while True: 6816 t = None if deadline is None else deadline - time.time() 6817 try: 6818 plumbing_response = svc.stub.List( 6819 req, 6820 metadata=svc.parent.get_metadata( 6821 'WorkflowApproversHistory.List', req), 6822 timeout=t) 6823 except Exception as e: 6824 if self.parent.shouldRetry(tries, e, deadline): 6825 tries += 1 6826 time.sleep( 6827 self.parent.exponentialBackoff(tries, deadline)) 6828 continue 6829 raise plumbing.convert_error_to_porcelain(e) from e 6830 tries = 0 6831 for plumbing_item in plumbing_response.history: 6832 yield plumbing.convert_workflow_approver_history_to_porcelain( 6833 plumbing_item) 6834 if plumbing_response.meta.next_cursor == '': 6835 break 6836 req.meta.cursor = plumbing_response.meta.next_cursor 6837 6838 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
6841class WorkflowRoles: 6842 ''' 6843 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 6844 to request access to a resource via the workflow. 6845 See `strongdm.models.WorkflowRole`. 6846 ''' 6847 def __init__(self, channel, client): 6848 self.parent = client 6849 self.stub = WorkflowRolesStub(channel) 6850 6851 def create(self, workflow_role, timeout=None): 6852 ''' 6853 Create creates a new workflow role 6854 ''' 6855 deadline = None if timeout is None else time.time() + timeout 6856 req = WorkflowRolesCreateRequest() 6857 6858 if workflow_role is not None: 6859 req.workflow_role.CopyFrom( 6860 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6861 tries = 0 6862 plumbing_response = None 6863 while True: 6864 t = None if deadline is None else deadline - time.time() 6865 try: 6866 plumbing_response = self.stub.Create( 6867 req, 6868 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6869 req), 6870 timeout=t) 6871 except Exception as e: 6872 if self.parent.shouldRetry(tries, e, deadline): 6873 tries += 1 6874 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6875 continue 6876 raise plumbing.convert_error_to_porcelain(e) from e 6877 break 6878 6879 resp = models.WorkflowRolesCreateResponse() 6880 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6881 plumbing_response.rate_limit) 6882 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6883 plumbing_response.workflow_role) 6884 return resp 6885 6886 def get(self, id, timeout=None): 6887 ''' 6888 Get reads one workflow role by ID. 6889 ''' 6890 deadline = None if timeout is None else time.time() + timeout 6891 req = WorkflowRoleGetRequest() 6892 if self.parent.snapshot_datetime is not None: 6893 req.meta.CopyFrom(GetRequestMetadata()) 6894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6895 6896 req.id = (id) 6897 tries = 0 6898 plumbing_response = None 6899 while True: 6900 t = None if deadline is None else deadline - time.time() 6901 try: 6902 plumbing_response = self.stub.Get( 6903 req, 6904 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6905 req), 6906 timeout=t) 6907 except Exception as e: 6908 if self.parent.shouldRetry(tries, e, deadline): 6909 tries += 1 6910 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6911 continue 6912 raise plumbing.convert_error_to_porcelain(e) from e 6913 break 6914 6915 resp = models.WorkflowRoleGetResponse() 6916 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6917 plumbing_response.meta) 6918 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6919 plumbing_response.rate_limit) 6920 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6921 plumbing_response.workflow_role) 6922 return resp 6923 6924 def delete(self, id, timeout=None): 6925 ''' 6926 Delete deletes a workflow role 6927 ''' 6928 deadline = None if timeout is None else time.time() + timeout 6929 req = WorkflowRolesDeleteRequest() 6930 6931 req.id = (id) 6932 tries = 0 6933 plumbing_response = None 6934 while True: 6935 t = None if deadline is None else deadline - time.time() 6936 try: 6937 plumbing_response = self.stub.Delete( 6938 req, 6939 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6940 req), 6941 timeout=t) 6942 except Exception as e: 6943 if self.parent.shouldRetry(tries, e, deadline): 6944 tries += 1 6945 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6946 continue 6947 raise plumbing.convert_error_to_porcelain(e) from e 6948 break 6949 6950 resp = models.WorkflowRolesDeleteResponse() 6951 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6952 plumbing_response.rate_limit) 6953 return resp 6954 6955 def list(self, filter, *args, timeout=None): 6956 ''' 6957 Lists existing workflow roles. 6958 ''' 6959 deadline = None if timeout is None else time.time() + timeout 6960 req = WorkflowRolesListRequest() 6961 req.meta.CopyFrom(ListRequestMetadata()) 6962 if self.parent.page_limit > 0: 6963 req.meta.limit = self.parent.page_limit 6964 if self.parent.snapshot_datetime is not None: 6965 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6966 6967 req.filter = plumbing.quote_filter_args(filter, *args) 6968 6969 def generator(svc, req): 6970 tries = 0 6971 while True: 6972 t = None if deadline is None else deadline - time.time() 6973 try: 6974 plumbing_response = svc.stub.List( 6975 req, 6976 metadata=svc.parent.get_metadata( 6977 'WorkflowRoles.List', req), 6978 timeout=t) 6979 except Exception as e: 6980 if self.parent.shouldRetry(tries, e, deadline): 6981 tries += 1 6982 time.sleep( 6983 self.parent.exponentialBackoff(tries, deadline)) 6984 continue 6985 raise plumbing.convert_error_to_porcelain(e) from e 6986 tries = 0 6987 for plumbing_item in plumbing_response.workflow_role: 6988 yield plumbing.convert_workflow_role_to_porcelain( 6989 plumbing_item) 6990 if plumbing_response.meta.next_cursor == '': 6991 break 6992 req.meta.cursor = plumbing_response.meta.next_cursor 6993 6994 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)
6851 def create(self, workflow_role, timeout=None): 6852 ''' 6853 Create creates a new workflow role 6854 ''' 6855 deadline = None if timeout is None else time.time() + timeout 6856 req = WorkflowRolesCreateRequest() 6857 6858 if workflow_role is not None: 6859 req.workflow_role.CopyFrom( 6860 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 6861 tries = 0 6862 plumbing_response = None 6863 while True: 6864 t = None if deadline is None else deadline - time.time() 6865 try: 6866 plumbing_response = self.stub.Create( 6867 req, 6868 metadata=self.parent.get_metadata('WorkflowRoles.Create', 6869 req), 6870 timeout=t) 6871 except Exception as e: 6872 if self.parent.shouldRetry(tries, e, deadline): 6873 tries += 1 6874 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6875 continue 6876 raise plumbing.convert_error_to_porcelain(e) from e 6877 break 6878 6879 resp = models.WorkflowRolesCreateResponse() 6880 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6881 plumbing_response.rate_limit) 6882 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6883 plumbing_response.workflow_role) 6884 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
6886 def get(self, id, timeout=None): 6887 ''' 6888 Get reads one workflow role by ID. 6889 ''' 6890 deadline = None if timeout is None else time.time() + timeout 6891 req = WorkflowRoleGetRequest() 6892 if self.parent.snapshot_datetime is not None: 6893 req.meta.CopyFrom(GetRequestMetadata()) 6894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6895 6896 req.id = (id) 6897 tries = 0 6898 plumbing_response = None 6899 while True: 6900 t = None if deadline is None else deadline - time.time() 6901 try: 6902 plumbing_response = self.stub.Get( 6903 req, 6904 metadata=self.parent.get_metadata('WorkflowRoles.Get', 6905 req), 6906 timeout=t) 6907 except Exception as e: 6908 if self.parent.shouldRetry(tries, e, deadline): 6909 tries += 1 6910 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6911 continue 6912 raise plumbing.convert_error_to_porcelain(e) from e 6913 break 6914 6915 resp = models.WorkflowRoleGetResponse() 6916 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6917 plumbing_response.meta) 6918 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6919 plumbing_response.rate_limit) 6920 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 6921 plumbing_response.workflow_role) 6922 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
6924 def delete(self, id, timeout=None): 6925 ''' 6926 Delete deletes a workflow role 6927 ''' 6928 deadline = None if timeout is None else time.time() + timeout 6929 req = WorkflowRolesDeleteRequest() 6930 6931 req.id = (id) 6932 tries = 0 6933 plumbing_response = None 6934 while True: 6935 t = None if deadline is None else deadline - time.time() 6936 try: 6937 plumbing_response = self.stub.Delete( 6938 req, 6939 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 6940 req), 6941 timeout=t) 6942 except Exception as e: 6943 if self.parent.shouldRetry(tries, e, deadline): 6944 tries += 1 6945 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6946 continue 6947 raise plumbing.convert_error_to_porcelain(e) from e 6948 break 6949 6950 resp = models.WorkflowRolesDeleteResponse() 6951 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6952 plumbing_response.rate_limit) 6953 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
6955 def list(self, filter, *args, timeout=None): 6956 ''' 6957 Lists existing workflow roles. 6958 ''' 6959 deadline = None if timeout is None else time.time() + timeout 6960 req = WorkflowRolesListRequest() 6961 req.meta.CopyFrom(ListRequestMetadata()) 6962 if self.parent.page_limit > 0: 6963 req.meta.limit = self.parent.page_limit 6964 if self.parent.snapshot_datetime is not None: 6965 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6966 6967 req.filter = plumbing.quote_filter_args(filter, *args) 6968 6969 def generator(svc, req): 6970 tries = 0 6971 while True: 6972 t = None if deadline is None else deadline - time.time() 6973 try: 6974 plumbing_response = svc.stub.List( 6975 req, 6976 metadata=svc.parent.get_metadata( 6977 'WorkflowRoles.List', req), 6978 timeout=t) 6979 except Exception as e: 6980 if self.parent.shouldRetry(tries, e, deadline): 6981 tries += 1 6982 time.sleep( 6983 self.parent.exponentialBackoff(tries, deadline)) 6984 continue 6985 raise plumbing.convert_error_to_porcelain(e) from e 6986 tries = 0 6987 for plumbing_item in plumbing_response.workflow_role: 6988 yield plumbing.convert_workflow_role_to_porcelain( 6989 plumbing_item) 6990 if plumbing_response.meta.next_cursor == '': 6991 break 6992 req.meta.cursor = plumbing_response.meta.next_cursor 6993 6994 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
6997class SnapshotWorkflowRoles: 6998 ''' 6999 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7000 service for historical queries. 7001 ''' 7002 def __init__(self, workflow_roles): 7003 self.workflow_roles = workflow_roles 7004 7005 def get(self, id, timeout=None): 7006 ''' 7007 Get reads one workflow role by ID. 7008 ''' 7009 return self.workflow_roles.get(id, timeout=timeout) 7010 7011 def list(self, filter, *args, timeout=None): 7012 ''' 7013 Lists existing workflow roles. 7014 ''' 7015 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
7018class WorkflowRolesHistory: 7019 ''' 7020 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7021 See `strongdm.models.WorkflowRoleHistory`. 7022 ''' 7023 def __init__(self, channel, client): 7024 self.parent = client 7025 self.stub = WorkflowRolesHistoryStub(channel) 7026 7027 def list(self, filter, *args, timeout=None): 7028 ''' 7029 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7030 ''' 7031 deadline = None if timeout is None else time.time() + timeout 7032 req = WorkflowRolesHistoryListRequest() 7033 req.meta.CopyFrom(ListRequestMetadata()) 7034 if self.parent.page_limit > 0: 7035 req.meta.limit = self.parent.page_limit 7036 if self.parent.snapshot_datetime is not None: 7037 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7038 7039 req.filter = plumbing.quote_filter_args(filter, *args) 7040 7041 def generator(svc, req): 7042 tries = 0 7043 while True: 7044 t = None if deadline is None else deadline - time.time() 7045 try: 7046 plumbing_response = svc.stub.List( 7047 req, 7048 metadata=svc.parent.get_metadata( 7049 'WorkflowRolesHistory.List', req), 7050 timeout=t) 7051 except Exception as e: 7052 if self.parent.shouldRetry(tries, e, deadline): 7053 tries += 1 7054 time.sleep( 7055 self.parent.exponentialBackoff(tries, deadline)) 7056 continue 7057 raise plumbing.convert_error_to_porcelain(e) from e 7058 tries = 0 7059 for plumbing_item in plumbing_response.history: 7060 yield plumbing.convert_workflow_role_history_to_porcelain( 7061 plumbing_item) 7062 if plumbing_response.meta.next_cursor == '': 7063 break 7064 req.meta.cursor = plumbing_response.meta.next_cursor 7065 7066 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)
7027 def list(self, filter, *args, timeout=None): 7028 ''' 7029 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7030 ''' 7031 deadline = None if timeout is None else time.time() + timeout 7032 req = WorkflowRolesHistoryListRequest() 7033 req.meta.CopyFrom(ListRequestMetadata()) 7034 if self.parent.page_limit > 0: 7035 req.meta.limit = self.parent.page_limit 7036 if self.parent.snapshot_datetime is not None: 7037 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7038 7039 req.filter = plumbing.quote_filter_args(filter, *args) 7040 7041 def generator(svc, req): 7042 tries = 0 7043 while True: 7044 t = None if deadline is None else deadline - time.time() 7045 try: 7046 plumbing_response = svc.stub.List( 7047 req, 7048 metadata=svc.parent.get_metadata( 7049 'WorkflowRolesHistory.List', req), 7050 timeout=t) 7051 except Exception as e: 7052 if self.parent.shouldRetry(tries, e, deadline): 7053 tries += 1 7054 time.sleep( 7055 self.parent.exponentialBackoff(tries, deadline)) 7056 continue 7057 raise plumbing.convert_error_to_porcelain(e) from e 7058 tries = 0 7059 for plumbing_item in plumbing_response.history: 7060 yield plumbing.convert_workflow_role_history_to_porcelain( 7061 plumbing_item) 7062 if plumbing_response.meta.next_cursor == '': 7063 break 7064 req.meta.cursor = plumbing_response.meta.next_cursor 7065 7066 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
7069class Workflows: 7070 ''' 7071 Workflows are the collection of rules that define the resources to which access can be requested, 7072 the users that can request that access, and the mechanism for approving those requests which can either 7073 be automatic approval or a set of users authorized to approve the requests. 7074 See `strongdm.models.Workflow`. 7075 ''' 7076 def __init__(self, channel, client): 7077 self.parent = client 7078 self.stub = WorkflowsStub(channel) 7079 7080 def create(self, workflow, timeout=None): 7081 ''' 7082 Create creates a new workflow and requires a name for the workflow. 7083 ''' 7084 deadline = None if timeout is None else time.time() + timeout 7085 req = WorkflowCreateRequest() 7086 7087 if workflow is not None: 7088 req.workflow.CopyFrom( 7089 plumbing.convert_workflow_to_plumbing(workflow)) 7090 tries = 0 7091 plumbing_response = None 7092 while True: 7093 t = None if deadline is None else deadline - time.time() 7094 try: 7095 plumbing_response = self.stub.Create( 7096 req, 7097 metadata=self.parent.get_metadata('Workflows.Create', req), 7098 timeout=t) 7099 except Exception as e: 7100 if self.parent.shouldRetry(tries, e, deadline): 7101 tries += 1 7102 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7103 continue 7104 raise plumbing.convert_error_to_porcelain(e) from e 7105 break 7106 7107 resp = models.WorkflowCreateResponse() 7108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7109 plumbing_response.rate_limit) 7110 resp.workflow = plumbing.convert_workflow_to_porcelain( 7111 plumbing_response.workflow) 7112 return resp 7113 7114 def get(self, id, timeout=None): 7115 ''' 7116 Get reads one workflow by ID. 7117 ''' 7118 deadline = None if timeout is None else time.time() + timeout 7119 req = WorkflowGetRequest() 7120 if self.parent.snapshot_datetime is not None: 7121 req.meta.CopyFrom(GetRequestMetadata()) 7122 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7123 7124 req.id = (id) 7125 tries = 0 7126 plumbing_response = None 7127 while True: 7128 t = None if deadline is None else deadline - time.time() 7129 try: 7130 plumbing_response = self.stub.Get( 7131 req, 7132 metadata=self.parent.get_metadata('Workflows.Get', req), 7133 timeout=t) 7134 except Exception as e: 7135 if self.parent.shouldRetry(tries, e, deadline): 7136 tries += 1 7137 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7138 continue 7139 raise plumbing.convert_error_to_porcelain(e) from e 7140 break 7141 7142 resp = models.WorkflowGetResponse() 7143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7144 plumbing_response.meta) 7145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7146 plumbing_response.rate_limit) 7147 resp.workflow = plumbing.convert_workflow_to_porcelain( 7148 plumbing_response.workflow) 7149 return resp 7150 7151 def delete(self, id, timeout=None): 7152 ''' 7153 Delete deletes an existing workflow. 7154 ''' 7155 deadline = None if timeout is None else time.time() + timeout 7156 req = WorkflowDeleteRequest() 7157 7158 req.id = (id) 7159 tries = 0 7160 plumbing_response = None 7161 while True: 7162 t = None if deadline is None else deadline - time.time() 7163 try: 7164 plumbing_response = self.stub.Delete( 7165 req, 7166 metadata=self.parent.get_metadata('Workflows.Delete', req), 7167 timeout=t) 7168 except Exception as e: 7169 if self.parent.shouldRetry(tries, e, deadline): 7170 tries += 1 7171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7172 continue 7173 raise plumbing.convert_error_to_porcelain(e) from e 7174 break 7175 7176 resp = models.WorkflowDeleteResponse() 7177 resp.id = (plumbing_response.id) 7178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7179 plumbing_response.rate_limit) 7180 return resp 7181 7182 def update(self, workflow, timeout=None): 7183 ''' 7184 Update updates an existing workflow. 7185 ''' 7186 deadline = None if timeout is None else time.time() + timeout 7187 req = WorkflowUpdateRequest() 7188 7189 if workflow is not None: 7190 req.workflow.CopyFrom( 7191 plumbing.convert_workflow_to_plumbing(workflow)) 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.Update( 7198 req, 7199 metadata=self.parent.get_metadata('Workflows.Update', 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.WorkflowUpdateResponse() 7210 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7211 plumbing_response.rate_limit) 7212 resp.workflow = plumbing.convert_workflow_to_porcelain( 7213 plumbing_response.workflow) 7214 return resp 7215 7216 def list(self, filter, *args, timeout=None): 7217 ''' 7218 Lists existing workflows. 7219 ''' 7220 deadline = None if timeout is None else time.time() + timeout 7221 req = WorkflowListRequest() 7222 req.meta.CopyFrom(ListRequestMetadata()) 7223 if self.parent.page_limit > 0: 7224 req.meta.limit = self.parent.page_limit 7225 if self.parent.snapshot_datetime is not None: 7226 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7227 7228 req.filter = plumbing.quote_filter_args(filter, *args) 7229 7230 def generator(svc, req): 7231 tries = 0 7232 while True: 7233 t = None if deadline is None else deadline - time.time() 7234 try: 7235 plumbing_response = svc.stub.List( 7236 req, 7237 metadata=svc.parent.get_metadata( 7238 'Workflows.List', req), 7239 timeout=t) 7240 except Exception as e: 7241 if self.parent.shouldRetry(tries, e, deadline): 7242 tries += 1 7243 time.sleep( 7244 self.parent.exponentialBackoff(tries, deadline)) 7245 continue 7246 raise plumbing.convert_error_to_porcelain(e) from e 7247 tries = 0 7248 for plumbing_item in plumbing_response.workflows: 7249 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7250 if plumbing_response.meta.next_cursor == '': 7251 break 7252 req.meta.cursor = plumbing_response.meta.next_cursor 7253 7254 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)
7080 def create(self, workflow, timeout=None): 7081 ''' 7082 Create creates a new workflow and requires a name for the workflow. 7083 ''' 7084 deadline = None if timeout is None else time.time() + timeout 7085 req = WorkflowCreateRequest() 7086 7087 if workflow is not None: 7088 req.workflow.CopyFrom( 7089 plumbing.convert_workflow_to_plumbing(workflow)) 7090 tries = 0 7091 plumbing_response = None 7092 while True: 7093 t = None if deadline is None else deadline - time.time() 7094 try: 7095 plumbing_response = self.stub.Create( 7096 req, 7097 metadata=self.parent.get_metadata('Workflows.Create', req), 7098 timeout=t) 7099 except Exception as e: 7100 if self.parent.shouldRetry(tries, e, deadline): 7101 tries += 1 7102 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7103 continue 7104 raise plumbing.convert_error_to_porcelain(e) from e 7105 break 7106 7107 resp = models.WorkflowCreateResponse() 7108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7109 plumbing_response.rate_limit) 7110 resp.workflow = plumbing.convert_workflow_to_porcelain( 7111 plumbing_response.workflow) 7112 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
7114 def get(self, id, timeout=None): 7115 ''' 7116 Get reads one workflow by ID. 7117 ''' 7118 deadline = None if timeout is None else time.time() + timeout 7119 req = WorkflowGetRequest() 7120 if self.parent.snapshot_datetime is not None: 7121 req.meta.CopyFrom(GetRequestMetadata()) 7122 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7123 7124 req.id = (id) 7125 tries = 0 7126 plumbing_response = None 7127 while True: 7128 t = None if deadline is None else deadline - time.time() 7129 try: 7130 plumbing_response = self.stub.Get( 7131 req, 7132 metadata=self.parent.get_metadata('Workflows.Get', req), 7133 timeout=t) 7134 except Exception as e: 7135 if self.parent.shouldRetry(tries, e, deadline): 7136 tries += 1 7137 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7138 continue 7139 raise plumbing.convert_error_to_porcelain(e) from e 7140 break 7141 7142 resp = models.WorkflowGetResponse() 7143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7144 plumbing_response.meta) 7145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7146 plumbing_response.rate_limit) 7147 resp.workflow = plumbing.convert_workflow_to_porcelain( 7148 plumbing_response.workflow) 7149 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
7151 def delete(self, id, timeout=None): 7152 ''' 7153 Delete deletes an existing workflow. 7154 ''' 7155 deadline = None if timeout is None else time.time() + timeout 7156 req = WorkflowDeleteRequest() 7157 7158 req.id = (id) 7159 tries = 0 7160 plumbing_response = None 7161 while True: 7162 t = None if deadline is None else deadline - time.time() 7163 try: 7164 plumbing_response = self.stub.Delete( 7165 req, 7166 metadata=self.parent.get_metadata('Workflows.Delete', req), 7167 timeout=t) 7168 except Exception as e: 7169 if self.parent.shouldRetry(tries, e, deadline): 7170 tries += 1 7171 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7172 continue 7173 raise plumbing.convert_error_to_porcelain(e) from e 7174 break 7175 7176 resp = models.WorkflowDeleteResponse() 7177 resp.id = (plumbing_response.id) 7178 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7179 plumbing_response.rate_limit) 7180 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
7182 def update(self, workflow, timeout=None): 7183 ''' 7184 Update updates an existing workflow. 7185 ''' 7186 deadline = None if timeout is None else time.time() + timeout 7187 req = WorkflowUpdateRequest() 7188 7189 if workflow is not None: 7190 req.workflow.CopyFrom( 7191 plumbing.convert_workflow_to_plumbing(workflow)) 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.Update( 7198 req, 7199 metadata=self.parent.get_metadata('Workflows.Update', 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.WorkflowUpdateResponse() 7210 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7211 plumbing_response.rate_limit) 7212 resp.workflow = plumbing.convert_workflow_to_porcelain( 7213 plumbing_response.workflow) 7214 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
7216 def list(self, filter, *args, timeout=None): 7217 ''' 7218 Lists existing workflows. 7219 ''' 7220 deadline = None if timeout is None else time.time() + timeout 7221 req = WorkflowListRequest() 7222 req.meta.CopyFrom(ListRequestMetadata()) 7223 if self.parent.page_limit > 0: 7224 req.meta.limit = self.parent.page_limit 7225 if self.parent.snapshot_datetime is not None: 7226 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7227 7228 req.filter = plumbing.quote_filter_args(filter, *args) 7229 7230 def generator(svc, req): 7231 tries = 0 7232 while True: 7233 t = None if deadline is None else deadline - time.time() 7234 try: 7235 plumbing_response = svc.stub.List( 7236 req, 7237 metadata=svc.parent.get_metadata( 7238 'Workflows.List', req), 7239 timeout=t) 7240 except Exception as e: 7241 if self.parent.shouldRetry(tries, e, deadline): 7242 tries += 1 7243 time.sleep( 7244 self.parent.exponentialBackoff(tries, deadline)) 7245 continue 7246 raise plumbing.convert_error_to_porcelain(e) from e 7247 tries = 0 7248 for plumbing_item in plumbing_response.workflows: 7249 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 7250 if plumbing_response.meta.next_cursor == '': 7251 break 7252 req.meta.cursor = plumbing_response.meta.next_cursor 7253 7254 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
7257class SnapshotWorkflows: 7258 ''' 7259 SnapshotWorkflows exposes the read only methods of the Workflows 7260 service for historical queries. 7261 ''' 7262 def __init__(self, workflows): 7263 self.workflows = workflows 7264 7265 def get(self, id, timeout=None): 7266 ''' 7267 Get reads one workflow by ID. 7268 ''' 7269 return self.workflows.get(id, timeout=timeout) 7270 7271 def list(self, filter, *args, timeout=None): 7272 ''' 7273 Lists existing workflows. 7274 ''' 7275 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
7278class WorkflowsHistory: 7279 ''' 7280 WorkflowsHistory provides records of all changes to the state of a Workflow. 7281 See `strongdm.models.WorkflowHistory`. 7282 ''' 7283 def __init__(self, channel, client): 7284 self.parent = client 7285 self.stub = WorkflowsHistoryStub(channel) 7286 7287 def list(self, filter, *args, timeout=None): 7288 ''' 7289 List gets a list of WorkflowHistory records matching a given set of criteria. 7290 ''' 7291 deadline = None if timeout is None else time.time() + timeout 7292 req = WorkflowHistoryListRequest() 7293 req.meta.CopyFrom(ListRequestMetadata()) 7294 if self.parent.page_limit > 0: 7295 req.meta.limit = self.parent.page_limit 7296 if self.parent.snapshot_datetime is not None: 7297 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7298 7299 req.filter = plumbing.quote_filter_args(filter, *args) 7300 7301 def generator(svc, req): 7302 tries = 0 7303 while True: 7304 t = None if deadline is None else deadline - time.time() 7305 try: 7306 plumbing_response = svc.stub.List( 7307 req, 7308 metadata=svc.parent.get_metadata( 7309 'WorkflowsHistory.List', req), 7310 timeout=t) 7311 except Exception as e: 7312 if self.parent.shouldRetry(tries, e, deadline): 7313 tries += 1 7314 time.sleep( 7315 self.parent.exponentialBackoff(tries, deadline)) 7316 continue 7317 raise plumbing.convert_error_to_porcelain(e) from e 7318 tries = 0 7319 for plumbing_item in plumbing_response.history: 7320 yield plumbing.convert_workflow_history_to_porcelain( 7321 plumbing_item) 7322 if plumbing_response.meta.next_cursor == '': 7323 break 7324 req.meta.cursor = plumbing_response.meta.next_cursor 7325 7326 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)
7287 def list(self, filter, *args, timeout=None): 7288 ''' 7289 List gets a list of WorkflowHistory records matching a given set of criteria. 7290 ''' 7291 deadline = None if timeout is None else time.time() + timeout 7292 req = WorkflowHistoryListRequest() 7293 req.meta.CopyFrom(ListRequestMetadata()) 7294 if self.parent.page_limit > 0: 7295 req.meta.limit = self.parent.page_limit 7296 if self.parent.snapshot_datetime is not None: 7297 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7298 7299 req.filter = plumbing.quote_filter_args(filter, *args) 7300 7301 def generator(svc, req): 7302 tries = 0 7303 while True: 7304 t = None if deadline is None else deadline - time.time() 7305 try: 7306 plumbing_response = svc.stub.List( 7307 req, 7308 metadata=svc.parent.get_metadata( 7309 'WorkflowsHistory.List', req), 7310 timeout=t) 7311 except Exception as e: 7312 if self.parent.shouldRetry(tries, e, deadline): 7313 tries += 1 7314 time.sleep( 7315 self.parent.exponentialBackoff(tries, deadline)) 7316 continue 7317 raise plumbing.convert_error_to_porcelain(e) from e 7318 tries = 0 7319 for plumbing_item in plumbing_response.history: 7320 yield plumbing.convert_workflow_history_to_porcelain( 7321 plumbing_item) 7322 if plumbing_response.meta.next_cursor == '': 7323 break 7324 req.meta.cursor = plumbing_response.meta.next_cursor 7325 7326 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.