strongdm 4.1.0 → 4.2.0

Sign up to get free protection for your applications and to get access to all the features.
data/lib/svc.rb CHANGED
@@ -1486,6 +1486,738 @@ module SDM #:nodoc:
1486
1486
  end
1487
1487
  end
1488
1488
 
1489
+ # PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group.
1490
+ #
1491
+ # See {PeeringGroupNode}.
1492
+ class PeeringGroupNodes
1493
+ extend Gem::Deprecate
1494
+
1495
+ def initialize(channel, parent)
1496
+ begin
1497
+ @stub = V1::PeeringGroupNodes::Stub.new(nil, nil, channel_override: channel)
1498
+ rescue => exception
1499
+ raise Plumbing::convert_error_to_porcelain(exception)
1500
+ end
1501
+ @parent = parent
1502
+ end
1503
+
1504
+ # Create attaches a Node to a PeeringGroup
1505
+ def create(
1506
+ peering_group_node,
1507
+ deadline: nil
1508
+ )
1509
+ req = V1::PeeringGroupNodeCreateRequest.new()
1510
+
1511
+ req.peering_group_node = Plumbing::convert_peering_group_node_to_plumbing(peering_group_node)
1512
+ tries = 0
1513
+ plumbing_response = nil
1514
+ loop do
1515
+ begin
1516
+ plumbing_response = @stub.create(req, metadata: @parent.get_metadata("PeeringGroupNodes.Create", req), deadline: deadline)
1517
+ rescue => exception
1518
+ if (@parent.shouldRetry(tries, exception))
1519
+ tries + +@parent.jitterSleep(tries)
1520
+ next
1521
+ end
1522
+ raise Plumbing::convert_error_to_porcelain(exception)
1523
+ end
1524
+ break
1525
+ end
1526
+
1527
+ resp = PeeringGroupNodeCreateResponse.new()
1528
+ resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
1529
+ resp.peering_group_node = Plumbing::convert_peering_group_node_to_porcelain(plumbing_response.peering_group_node)
1530
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1531
+ resp
1532
+ end
1533
+
1534
+ # Delete detaches a Node to a PeeringGroup.
1535
+ def delete(
1536
+ id,
1537
+ deadline: nil
1538
+ )
1539
+ req = V1::PeeringGroupNodeDeleteRequest.new()
1540
+
1541
+ req.id = (id)
1542
+ tries = 0
1543
+ plumbing_response = nil
1544
+ loop do
1545
+ begin
1546
+ plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("PeeringGroupNodes.Delete", req), deadline: deadline)
1547
+ rescue => exception
1548
+ if (@parent.shouldRetry(tries, exception))
1549
+ tries + +@parent.jitterSleep(tries)
1550
+ next
1551
+ end
1552
+ raise Plumbing::convert_error_to_porcelain(exception)
1553
+ end
1554
+ break
1555
+ end
1556
+
1557
+ resp = PeeringGroupNodeDeleteResponse.new()
1558
+ resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
1559
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1560
+ resp
1561
+ end
1562
+
1563
+ # Get reads the information of one peering group to node attachment.
1564
+ def get(
1565
+ id,
1566
+ deadline: nil
1567
+ )
1568
+ req = V1::PeeringGroupNodeGetRequest.new()
1569
+ if not @parent.snapshot_time.nil?
1570
+ req.meta = V1::GetRequestMetadata.new()
1571
+ req.meta.snapshot_at = @parent.snapshot_time
1572
+ end
1573
+
1574
+ req.id = (id)
1575
+ tries = 0
1576
+ plumbing_response = nil
1577
+ loop do
1578
+ begin
1579
+ plumbing_response = @stub.get(req, metadata: @parent.get_metadata("PeeringGroupNodes.Get", req), deadline: deadline)
1580
+ rescue => exception
1581
+ if (@parent.shouldRetry(tries, exception))
1582
+ tries + +@parent.jitterSleep(tries)
1583
+ next
1584
+ end
1585
+ raise Plumbing::convert_error_to_porcelain(exception)
1586
+ end
1587
+ break
1588
+ end
1589
+
1590
+ resp = PeeringGroupNodeGetResponse.new()
1591
+ resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
1592
+ resp.peering_group_node = Plumbing::convert_peering_group_node_to_porcelain(plumbing_response.peering_group_node)
1593
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1594
+ resp
1595
+ end
1596
+
1597
+ # List gets a list of peering group node attachments.
1598
+ def list(
1599
+ filter,
1600
+ *args,
1601
+ deadline: nil
1602
+ )
1603
+ req = V1::PeeringGroupNodeListRequest.new()
1604
+ req.meta = V1::ListRequestMetadata.new()
1605
+ page_size_option = @parent._test_options["PageSize"]
1606
+ if page_size_option.is_a? Integer
1607
+ req.meta.limit = page_size_option
1608
+ end
1609
+ if not @parent.snapshot_time.nil?
1610
+ req.meta.snapshot_at = @parent.snapshot_time
1611
+ end
1612
+
1613
+ req.filter = Plumbing::quote_filter_args(filter, *args)
1614
+ resp = Enumerator::Generator.new { |g|
1615
+ tries = 0
1616
+ loop do
1617
+ begin
1618
+ plumbing_response = @stub.list(req, metadata: @parent.get_metadata("PeeringGroupNodes.List", req), deadline: deadline)
1619
+ rescue => exception
1620
+ if (@parent.shouldRetry(tries, exception))
1621
+ tries + +@parent.jitterSleep(tries)
1622
+ next
1623
+ end
1624
+ raise Plumbing::convert_error_to_porcelain(exception)
1625
+ end
1626
+ tries = 0
1627
+ plumbing_response.peering_group_nodes.each do |plumbing_item|
1628
+ g.yield Plumbing::convert_peering_group_node_to_porcelain(plumbing_item)
1629
+ end
1630
+ break if plumbing_response.meta.next_cursor == ""
1631
+ req.meta.cursor = plumbing_response.meta.next_cursor
1632
+ end
1633
+ }
1634
+ resp
1635
+ end
1636
+ end
1637
+
1638
+ # SnapshotPeeringGroupNodes exposes the read only methods of the PeeringGroupNodes
1639
+ # service for historical queries.
1640
+ class SnapshotPeeringGroupNodes
1641
+ extend Gem::Deprecate
1642
+
1643
+ def initialize(peering_group_nodes)
1644
+ @peering_group_nodes = peering_group_nodes
1645
+ end
1646
+
1647
+ # Get reads the information of one peering group to node attachment.
1648
+ def get(
1649
+ id,
1650
+ deadline: nil
1651
+ )
1652
+ return @peering_group_nodes.get(
1653
+ id,
1654
+ deadline: deadline,
1655
+ )
1656
+ end
1657
+
1658
+ # List gets a list of peering group node attachments.
1659
+ def list(
1660
+ filter,
1661
+ *args,
1662
+ deadline: nil
1663
+ )
1664
+ return @peering_group_nodes.list(
1665
+ filter,
1666
+ *args,
1667
+ deadline: deadline,
1668
+ )
1669
+ end
1670
+ end
1671
+
1672
+ # PeeringGroupPeers provides the building blocks necessary to link two peering groups.
1673
+ #
1674
+ # See {PeeringGroupPeer}.
1675
+ class PeeringGroupPeers
1676
+ extend Gem::Deprecate
1677
+
1678
+ def initialize(channel, parent)
1679
+ begin
1680
+ @stub = V1::PeeringGroupPeers::Stub.new(nil, nil, channel_override: channel)
1681
+ rescue => exception
1682
+ raise Plumbing::convert_error_to_porcelain(exception)
1683
+ end
1684
+ @parent = parent
1685
+ end
1686
+
1687
+ # Create links two peering groups.
1688
+ def create(
1689
+ peering_group_peer,
1690
+ deadline: nil
1691
+ )
1692
+ req = V1::PeeringGroupPeerCreateRequest.new()
1693
+
1694
+ req.peering_group_peer = Plumbing::convert_peering_group_peer_to_plumbing(peering_group_peer)
1695
+ tries = 0
1696
+ plumbing_response = nil
1697
+ loop do
1698
+ begin
1699
+ plumbing_response = @stub.create(req, metadata: @parent.get_metadata("PeeringGroupPeers.Create", req), deadline: deadline)
1700
+ rescue => exception
1701
+ if (@parent.shouldRetry(tries, exception))
1702
+ tries + +@parent.jitterSleep(tries)
1703
+ next
1704
+ end
1705
+ raise Plumbing::convert_error_to_porcelain(exception)
1706
+ end
1707
+ break
1708
+ end
1709
+
1710
+ resp = PeeringGroupPeerCreateResponse.new()
1711
+ resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
1712
+ resp.peering_group_peer = Plumbing::convert_peering_group_peer_to_porcelain(plumbing_response.peering_group_peer)
1713
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1714
+ resp
1715
+ end
1716
+
1717
+ # Delete unlinks two peering groups.
1718
+ def delete(
1719
+ id,
1720
+ deadline: nil
1721
+ )
1722
+ req = V1::PeeringGroupPeerDeleteRequest.new()
1723
+
1724
+ req.id = (id)
1725
+ tries = 0
1726
+ plumbing_response = nil
1727
+ loop do
1728
+ begin
1729
+ plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("PeeringGroupPeers.Delete", req), deadline: deadline)
1730
+ rescue => exception
1731
+ if (@parent.shouldRetry(tries, exception))
1732
+ tries + +@parent.jitterSleep(tries)
1733
+ next
1734
+ end
1735
+ raise Plumbing::convert_error_to_porcelain(exception)
1736
+ end
1737
+ break
1738
+ end
1739
+
1740
+ resp = PeeringGroupPeerDeleteResponse.new()
1741
+ resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
1742
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1743
+ resp
1744
+ end
1745
+
1746
+ # Get reads the information of one peering group link.
1747
+ def get(
1748
+ id,
1749
+ deadline: nil
1750
+ )
1751
+ req = V1::PeeringGroupPeerGetRequest.new()
1752
+ if not @parent.snapshot_time.nil?
1753
+ req.meta = V1::GetRequestMetadata.new()
1754
+ req.meta.snapshot_at = @parent.snapshot_time
1755
+ end
1756
+
1757
+ req.id = (id)
1758
+ tries = 0
1759
+ plumbing_response = nil
1760
+ loop do
1761
+ begin
1762
+ plumbing_response = @stub.get(req, metadata: @parent.get_metadata("PeeringGroupPeers.Get", req), deadline: deadline)
1763
+ rescue => exception
1764
+ if (@parent.shouldRetry(tries, exception))
1765
+ tries + +@parent.jitterSleep(tries)
1766
+ next
1767
+ end
1768
+ raise Plumbing::convert_error_to_porcelain(exception)
1769
+ end
1770
+ break
1771
+ end
1772
+
1773
+ resp = PeeringGroupPeerGetResponse.new()
1774
+ resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
1775
+ resp.peering_group_peer = Plumbing::convert_peering_group_peer_to_porcelain(plumbing_response.peering_group_peer)
1776
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1777
+ resp
1778
+ end
1779
+
1780
+ # List gets a list of peering group links.
1781
+ def list(
1782
+ filter,
1783
+ *args,
1784
+ deadline: nil
1785
+ )
1786
+ req = V1::PeeringGroupPeerListRequest.new()
1787
+ req.meta = V1::ListRequestMetadata.new()
1788
+ page_size_option = @parent._test_options["PageSize"]
1789
+ if page_size_option.is_a? Integer
1790
+ req.meta.limit = page_size_option
1791
+ end
1792
+ if not @parent.snapshot_time.nil?
1793
+ req.meta.snapshot_at = @parent.snapshot_time
1794
+ end
1795
+
1796
+ req.filter = Plumbing::quote_filter_args(filter, *args)
1797
+ resp = Enumerator::Generator.new { |g|
1798
+ tries = 0
1799
+ loop do
1800
+ begin
1801
+ plumbing_response = @stub.list(req, metadata: @parent.get_metadata("PeeringGroupPeers.List", req), deadline: deadline)
1802
+ rescue => exception
1803
+ if (@parent.shouldRetry(tries, exception))
1804
+ tries + +@parent.jitterSleep(tries)
1805
+ next
1806
+ end
1807
+ raise Plumbing::convert_error_to_porcelain(exception)
1808
+ end
1809
+ tries = 0
1810
+ plumbing_response.peering_group_peers.each do |plumbing_item|
1811
+ g.yield Plumbing::convert_peering_group_peer_to_porcelain(plumbing_item)
1812
+ end
1813
+ break if plumbing_response.meta.next_cursor == ""
1814
+ req.meta.cursor = plumbing_response.meta.next_cursor
1815
+ end
1816
+ }
1817
+ resp
1818
+ end
1819
+ end
1820
+
1821
+ # SnapshotPeeringGroupPeers exposes the read only methods of the PeeringGroupPeers
1822
+ # service for historical queries.
1823
+ class SnapshotPeeringGroupPeers
1824
+ extend Gem::Deprecate
1825
+
1826
+ def initialize(peering_group_peers)
1827
+ @peering_group_peers = peering_group_peers
1828
+ end
1829
+
1830
+ # Get reads the information of one peering group link.
1831
+ def get(
1832
+ id,
1833
+ deadline: nil
1834
+ )
1835
+ return @peering_group_peers.get(
1836
+ id,
1837
+ deadline: deadline,
1838
+ )
1839
+ end
1840
+
1841
+ # List gets a list of peering group links.
1842
+ def list(
1843
+ filter,
1844
+ *args,
1845
+ deadline: nil
1846
+ )
1847
+ return @peering_group_peers.list(
1848
+ filter,
1849
+ *args,
1850
+ deadline: deadline,
1851
+ )
1852
+ end
1853
+ end
1854
+
1855
+ # PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group.
1856
+ #
1857
+ # See {PeeringGroupResource}.
1858
+ class PeeringGroupResources
1859
+ extend Gem::Deprecate
1860
+
1861
+ def initialize(channel, parent)
1862
+ begin
1863
+ @stub = V1::PeeringGroupResources::Stub.new(nil, nil, channel_override: channel)
1864
+ rescue => exception
1865
+ raise Plumbing::convert_error_to_porcelain(exception)
1866
+ end
1867
+ @parent = parent
1868
+ end
1869
+
1870
+ # Create attaches a Resource to a PeeringGroup
1871
+ def create(
1872
+ peering_group_resource,
1873
+ deadline: nil
1874
+ )
1875
+ req = V1::PeeringGroupResourceCreateRequest.new()
1876
+
1877
+ req.peering_group_resource = Plumbing::convert_peering_group_resource_to_plumbing(peering_group_resource)
1878
+ tries = 0
1879
+ plumbing_response = nil
1880
+ loop do
1881
+ begin
1882
+ plumbing_response = @stub.create(req, metadata: @parent.get_metadata("PeeringGroupResources.Create", req), deadline: deadline)
1883
+ rescue => exception
1884
+ if (@parent.shouldRetry(tries, exception))
1885
+ tries + +@parent.jitterSleep(tries)
1886
+ next
1887
+ end
1888
+ raise Plumbing::convert_error_to_porcelain(exception)
1889
+ end
1890
+ break
1891
+ end
1892
+
1893
+ resp = PeeringGroupResourceCreateResponse.new()
1894
+ resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
1895
+ resp.peering_group_resource = Plumbing::convert_peering_group_resource_to_porcelain(plumbing_response.peering_group_resource)
1896
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1897
+ resp
1898
+ end
1899
+
1900
+ # Delete detaches a Resource to a PeeringGroup
1901
+ def delete(
1902
+ id,
1903
+ deadline: nil
1904
+ )
1905
+ req = V1::PeeringGroupResourceDeleteRequest.new()
1906
+
1907
+ req.id = (id)
1908
+ tries = 0
1909
+ plumbing_response = nil
1910
+ loop do
1911
+ begin
1912
+ plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("PeeringGroupResources.Delete", req), deadline: deadline)
1913
+ rescue => exception
1914
+ if (@parent.shouldRetry(tries, exception))
1915
+ tries + +@parent.jitterSleep(tries)
1916
+ next
1917
+ end
1918
+ raise Plumbing::convert_error_to_porcelain(exception)
1919
+ end
1920
+ break
1921
+ end
1922
+
1923
+ resp = PeeringGroupResourceDeleteResponse.new()
1924
+ resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
1925
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1926
+ resp
1927
+ end
1928
+
1929
+ # Get reads the information of one peering group to resource attachment.
1930
+ def get(
1931
+ id,
1932
+ deadline: nil
1933
+ )
1934
+ req = V1::PeeringGroupResourceGetRequest.new()
1935
+ if not @parent.snapshot_time.nil?
1936
+ req.meta = V1::GetRequestMetadata.new()
1937
+ req.meta.snapshot_at = @parent.snapshot_time
1938
+ end
1939
+
1940
+ req.id = (id)
1941
+ tries = 0
1942
+ plumbing_response = nil
1943
+ loop do
1944
+ begin
1945
+ plumbing_response = @stub.get(req, metadata: @parent.get_metadata("PeeringGroupResources.Get", req), deadline: deadline)
1946
+ rescue => exception
1947
+ if (@parent.shouldRetry(tries, exception))
1948
+ tries + +@parent.jitterSleep(tries)
1949
+ next
1950
+ end
1951
+ raise Plumbing::convert_error_to_porcelain(exception)
1952
+ end
1953
+ break
1954
+ end
1955
+
1956
+ resp = PeeringGroupResourceGetResponse.new()
1957
+ resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
1958
+ resp.peering_group_resource = Plumbing::convert_peering_group_resource_to_porcelain(plumbing_response.peering_group_resource)
1959
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
1960
+ resp
1961
+ end
1962
+
1963
+ # List gets a list of peering group resource attachments.
1964
+ def list(
1965
+ filter,
1966
+ *args,
1967
+ deadline: nil
1968
+ )
1969
+ req = V1::PeeringGroupResourceListRequest.new()
1970
+ req.meta = V1::ListRequestMetadata.new()
1971
+ page_size_option = @parent._test_options["PageSize"]
1972
+ if page_size_option.is_a? Integer
1973
+ req.meta.limit = page_size_option
1974
+ end
1975
+ if not @parent.snapshot_time.nil?
1976
+ req.meta.snapshot_at = @parent.snapshot_time
1977
+ end
1978
+
1979
+ req.filter = Plumbing::quote_filter_args(filter, *args)
1980
+ resp = Enumerator::Generator.new { |g|
1981
+ tries = 0
1982
+ loop do
1983
+ begin
1984
+ plumbing_response = @stub.list(req, metadata: @parent.get_metadata("PeeringGroupResources.List", req), deadline: deadline)
1985
+ rescue => exception
1986
+ if (@parent.shouldRetry(tries, exception))
1987
+ tries + +@parent.jitterSleep(tries)
1988
+ next
1989
+ end
1990
+ raise Plumbing::convert_error_to_porcelain(exception)
1991
+ end
1992
+ tries = 0
1993
+ plumbing_response.peering_group_resources.each do |plumbing_item|
1994
+ g.yield Plumbing::convert_peering_group_resource_to_porcelain(plumbing_item)
1995
+ end
1996
+ break if plumbing_response.meta.next_cursor == ""
1997
+ req.meta.cursor = plumbing_response.meta.next_cursor
1998
+ end
1999
+ }
2000
+ resp
2001
+ end
2002
+ end
2003
+
2004
+ # SnapshotPeeringGroupResources exposes the read only methods of the PeeringGroupResources
2005
+ # service for historical queries.
2006
+ class SnapshotPeeringGroupResources
2007
+ extend Gem::Deprecate
2008
+
2009
+ def initialize(peering_group_resources)
2010
+ @peering_group_resources = peering_group_resources
2011
+ end
2012
+
2013
+ # Get reads the information of one peering group to resource attachment.
2014
+ def get(
2015
+ id,
2016
+ deadline: nil
2017
+ )
2018
+ return @peering_group_resources.get(
2019
+ id,
2020
+ deadline: deadline,
2021
+ )
2022
+ end
2023
+
2024
+ # List gets a list of peering group resource attachments.
2025
+ def list(
2026
+ filter,
2027
+ *args,
2028
+ deadline: nil
2029
+ )
2030
+ return @peering_group_resources.list(
2031
+ filter,
2032
+ *args,
2033
+ deadline: deadline,
2034
+ )
2035
+ end
2036
+ end
2037
+
2038
+ # PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing.
2039
+ #
2040
+ # See {PeeringGroup}.
2041
+ class PeeringGroups
2042
+ extend Gem::Deprecate
2043
+
2044
+ def initialize(channel, parent)
2045
+ begin
2046
+ @stub = V1::PeeringGroups::Stub.new(nil, nil, channel_override: channel)
2047
+ rescue => exception
2048
+ raise Plumbing::convert_error_to_porcelain(exception)
2049
+ end
2050
+ @parent = parent
2051
+ end
2052
+
2053
+ # Create registers a new PeeringGroup.
2054
+ def create(
2055
+ peering_group,
2056
+ deadline: nil
2057
+ )
2058
+ req = V1::PeeringGroupCreateRequest.new()
2059
+
2060
+ req.peering_group = Plumbing::convert_peering_group_to_plumbing(peering_group)
2061
+ tries = 0
2062
+ plumbing_response = nil
2063
+ loop do
2064
+ begin
2065
+ plumbing_response = @stub.create(req, metadata: @parent.get_metadata("PeeringGroups.Create", req), deadline: deadline)
2066
+ rescue => exception
2067
+ if (@parent.shouldRetry(tries, exception))
2068
+ tries + +@parent.jitterSleep(tries)
2069
+ next
2070
+ end
2071
+ raise Plumbing::convert_error_to_porcelain(exception)
2072
+ end
2073
+ break
2074
+ end
2075
+
2076
+ resp = PeeringGroupCreateResponse.new()
2077
+ resp.meta = Plumbing::convert_create_response_metadata_to_porcelain(plumbing_response.meta)
2078
+ resp.peering_group = Plumbing::convert_peering_group_to_porcelain(plumbing_response.peering_group)
2079
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
2080
+ resp
2081
+ end
2082
+
2083
+ # Delete removes a PeeringGroup by ID.
2084
+ def delete(
2085
+ id,
2086
+ deadline: nil
2087
+ )
2088
+ req = V1::PeeringGroupDeleteRequest.new()
2089
+
2090
+ req.id = (id)
2091
+ tries = 0
2092
+ plumbing_response = nil
2093
+ loop do
2094
+ begin
2095
+ plumbing_response = @stub.delete(req, metadata: @parent.get_metadata("PeeringGroups.Delete", req), deadline: deadline)
2096
+ rescue => exception
2097
+ if (@parent.shouldRetry(tries, exception))
2098
+ tries + +@parent.jitterSleep(tries)
2099
+ next
2100
+ end
2101
+ raise Plumbing::convert_error_to_porcelain(exception)
2102
+ end
2103
+ break
2104
+ end
2105
+
2106
+ resp = PeeringGroupDeleteResponse.new()
2107
+ resp.meta = Plumbing::convert_delete_response_metadata_to_porcelain(plumbing_response.meta)
2108
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
2109
+ resp
2110
+ end
2111
+
2112
+ # Get reads one PeeringGroup by ID. It will load all its dependencies.
2113
+ def get(
2114
+ id,
2115
+ deadline: nil
2116
+ )
2117
+ req = V1::PeeringGroupGetRequest.new()
2118
+ if not @parent.snapshot_time.nil?
2119
+ req.meta = V1::GetRequestMetadata.new()
2120
+ req.meta.snapshot_at = @parent.snapshot_time
2121
+ end
2122
+
2123
+ req.id = (id)
2124
+ tries = 0
2125
+ plumbing_response = nil
2126
+ loop do
2127
+ begin
2128
+ plumbing_response = @stub.get(req, metadata: @parent.get_metadata("PeeringGroups.Get", req), deadline: deadline)
2129
+ rescue => exception
2130
+ if (@parent.shouldRetry(tries, exception))
2131
+ tries + +@parent.jitterSleep(tries)
2132
+ next
2133
+ end
2134
+ raise Plumbing::convert_error_to_porcelain(exception)
2135
+ end
2136
+ break
2137
+ end
2138
+
2139
+ resp = PeeringGroupGetResponse.new()
2140
+ resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)
2141
+ resp.peering_group = Plumbing::convert_peering_group_to_porcelain(plumbing_response.peering_group)
2142
+ resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)
2143
+ resp
2144
+ end
2145
+
2146
+ # List gets a list of Peering Groups.
2147
+ def list(
2148
+ filter,
2149
+ *args,
2150
+ deadline: nil
2151
+ )
2152
+ req = V1::PeeringGroupListRequest.new()
2153
+ req.meta = V1::ListRequestMetadata.new()
2154
+ page_size_option = @parent._test_options["PageSize"]
2155
+ if page_size_option.is_a? Integer
2156
+ req.meta.limit = page_size_option
2157
+ end
2158
+ if not @parent.snapshot_time.nil?
2159
+ req.meta.snapshot_at = @parent.snapshot_time
2160
+ end
2161
+
2162
+ req.filter = Plumbing::quote_filter_args(filter, *args)
2163
+ resp = Enumerator::Generator.new { |g|
2164
+ tries = 0
2165
+ loop do
2166
+ begin
2167
+ plumbing_response = @stub.list(req, metadata: @parent.get_metadata("PeeringGroups.List", req), deadline: deadline)
2168
+ rescue => exception
2169
+ if (@parent.shouldRetry(tries, exception))
2170
+ tries + +@parent.jitterSleep(tries)
2171
+ next
2172
+ end
2173
+ raise Plumbing::convert_error_to_porcelain(exception)
2174
+ end
2175
+ tries = 0
2176
+ plumbing_response.peering_groups.each do |plumbing_item|
2177
+ g.yield Plumbing::convert_peering_group_to_porcelain(plumbing_item)
2178
+ end
2179
+ break if plumbing_response.meta.next_cursor == ""
2180
+ req.meta.cursor = plumbing_response.meta.next_cursor
2181
+ end
2182
+ }
2183
+ resp
2184
+ end
2185
+ end
2186
+
2187
+ # SnapshotPeeringGroups exposes the read only methods of the PeeringGroups
2188
+ # service for historical queries.
2189
+ class SnapshotPeeringGroups
2190
+ extend Gem::Deprecate
2191
+
2192
+ def initialize(peering_groups)
2193
+ @peering_groups = peering_groups
2194
+ end
2195
+
2196
+ # Get reads one PeeringGroup by ID. It will load all its dependencies.
2197
+ def get(
2198
+ id,
2199
+ deadline: nil
2200
+ )
2201
+ return @peering_groups.get(
2202
+ id,
2203
+ deadline: deadline,
2204
+ )
2205
+ end
2206
+
2207
+ # List gets a list of Peering Groups.
2208
+ def list(
2209
+ filter,
2210
+ *args,
2211
+ deadline: nil
2212
+ )
2213
+ return @peering_groups.list(
2214
+ filter,
2215
+ *args,
2216
+ deadline: deadline,
2217
+ )
2218
+ end
2219
+ end
2220
+
1489
2221
  # A Query is a record of a single client request to a resource, such as a SQL query.
1490
2222
  # Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries.
1491
2223
  # The Queries service is read-only.