def testEq(self):
client = object()
service = object()
regional_lister1 = lister.MultiScopeLister(client, regional_service=service)
regional_lister2 = lister.MultiScopeLister(client, regional_service=service)
self.assertEqual(regional_lister1, regional_lister2)
self.assertEqual(hash(regional_lister1), hash(regional_lister2))
def testNeq(self):
client1 = object()
client2 = object()
service = object()
regional_lister1 = lister.MultiScopeLister(
client1, regional_service=service)
regional_lister2 = lister.MultiScopeLister(
client2, regional_service=service)
self.assertNotEqual(regional_lister1, regional_lister2)
def Run(self, args):
args.GetDisplayInfo().AddTransforms({
'description':
_TransformShareSettings,
})
if args.share_settings:
args.GetDisplayInfo().AddFormat("""\
table(
name,
zone.basename(),
description,
nodeTemplate.basename(),
size:label=NODES,
shareSettings.description()
)""")
else:
args.GetDisplayInfo().AddFormat("""\
table(
name,
zone.basename(),
description,
nodeTemplate.basename(),
size:label=NODES,
shareSettings.yesno(yes="true", no="false"):label=SHARED
)""")
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client, aggregation_service=client.apitools_client.nodeGroups)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
"""Yields images from (potentially) multiple projects."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
def ParseProject(project):
return holder.resources.Parse(None, {'project': project},
collection='compute.projects')
if args.standard_images:
for project in constants.PUBLIC_IMAGE_PROJECTS:
request_data.scope_set.add(ParseProject(project))
if args.preview_images:
for project in constants.PREVIEW_IMAGE_PROJECTS:
request_data.scope_set.add(ParseProject(project))
list_implementation = lister.MultiScopeLister(
client, global_service=client.apitools_client.images)
images = lister.Invoke(request_data, list_implementation)
return self.AugmentImagesStatus(holder.resources,
self._FilterDeprecated(args, images))
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client, aggregation_service=client.apitools_client.nodeGroups)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionSslCertificates,
global_service=client.apitools_client.sslCertificates,
aggregation_service=client.apitools_client.sslCertificates,
return_partial_success=self._return_partial_success)
return lister.Invoke(request_data, list_implementation)
def testRepr(self):
multi_scope_lister = lister.MultiScopeLister(
'client', 'zonal_service', 'regional_service', 'global_service',
'aggregation_service')
# Python 2: u"MultiScopeLister(u'client', u'zonal_service',
# u'regional_service', u'global_service', u'aggregation_service')"
# Python 3: "MultiScopeLister('client', 'zonal_service','regional_service',
# 'global_service', 'aggregation_service')"
expected = 'MultiScopeLister({}, {}, {}, {}, {}, {}, {})'.format(
repr('client'), repr('zonal_service'), repr('regional_service'),
repr('global_service'), repr('aggregation_service'), repr(True),
repr(False))
self.assertEqual(repr(multi_scope_lister), expected)
def _Run(args, holder):
"""Issues request necessary to list forwarding rules."""
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.forwardingRules,
global_service=client.apitools_client.globalForwardingRules,
aggregation_service=client.apitools_client.forwardingRules)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instanceGroups,
regional_service=client.apitools_client.regionInstanceGroups,
aggregation_service=client.apitools_client.instanceGroups)
return self.ComputeDynamicProperties(
args, lister.Invoke(request_data, list_implementation), holder)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.publicDelegatedPrefixes,
global_service=client.apitools_client.
globalPublicDelegatedPrefixes,
aggregation_service=client.apitools_client.publicDelegatedPrefixes)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.networkEndpointGroups,
regional_service=client.apitools_client.regionNetworkEndpointGroups
if self.support_regional_scope else None,
global_service=client.apitools_client.globalNetworkEndpointGroups
if self.support_global_scope else None,
aggregation_service=client.apitools_client.networkEndpointGroups)
return lister.Invoke(request_data, list_implementation)
def _Run(args, holder, include_l7_internal_load_balancing):
"""Issues requests necessary to list URL maps."""
client = holder.client
if include_l7_internal_load_balancing:
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionUrlMaps,
global_service=client.apitools_client.urlMaps,
aggregation_service=client.apitools_client.urlMaps)
else:
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.urlMaps)
return lister.Invoke(request_data, list_implementation)
def testWithPartialError(self):
def make_server_responses(*_, **kwargs):
for num in range(5):
if num == 2:
kwargs['errors'].append((400, 'Invalid field name'))
else:
yield num
lister_patcher = mock.patch(
'googlecloudsdk.api_lib.compute.request_helper.ListJson',
autospec=True)
self.addCleanup(lister_patcher.stop)
self.list_json = lister_patcher.start()
self.list_json.side_effect = make_server_responses
self.api_mock = utils.ComputeApiMock('v1').Start()
self.addCleanup(self.api_mock.Stop)
resource_registry = resources.REGISTRY.Clone()
resource_registry.RegisterApiByName('compute', 'v1')
project = resource_registry.Parse(
'https://www.googleapis.com/compute/v1/projects/lister-project')
frontend = lister._Frontend('filter', 123,
lister.GlobalScope([project]))
zones_lister = lister.MultiScopeLister(
self.api_mock.adapter,
global_service=self.api_mock.adapter.apitools_client.zones)
result = list(zones_lister(frontend))
self.assertListEqual(result, [0, 1, 3, 4])
errors = [(400, u'Invalid field name')]
self.list_json.assert_called_once_with(
requests=[(self.api_mock.adapter.apitools_client.zones, 'List',
self.api_mock.adapter.messages.ComputeZonesListRequest(
filter='filter',
maxResults=123,
project='lister-project')),
],
http=self.api_mock.adapter.apitools_client.http,
batch_url=self.api_mock.adapter.batch_url,
errors=errors)
def Run(self, args):
query = resource_filter.Compile(self._GetInventoryFilterQuery(args))
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instances,
aggregation_service=client.apitools_client.instances)
instances_iterator = lister.Invoke(request_data, list_implementation)
instances = list(instances_iterator)
responses = self._GetAllGuestInventoryGuestAttributes(holder, instances)
return self._GetInventoryFilteredInstances(instances, responses, query)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client=client,
regional_service=client.apitools_client.subnetworks,
aggregation_service=client.apitools_client.subnetworks)
for resource in lister.Invoke(request_data, list_implementation):
if args.network is None:
yield resource
elif 'network' in resource:
network_ref = holder.resources.Parse(resource['network'])
if network_ref.Name() == args.network:
yield resource
def _Run(args, holder, include_l7_internal_load_balancing,
return_partial_success):
"""Issues requests necessary to list Target HTTPS Proxies."""
client = holder.client
if include_l7_internal_load_balancing:
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionTargetHttpsProxies,
global_service=client.apitools_client.targetHttpsProxies,
aggregation_service=client.apitools_client.targetHttpsProxies,
return_partial_success=return_partial_success)
else:
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.targetHttpsProxies)
return lister.Invoke(request_data, list_implementation)
def testAggregatedListPartialSuccess(self):
lister_patcher = mock.patch(
'googlecloudsdk.api_lib.compute.request_helper.ListJson',
autospec=True)
self.addCleanup(lister_patcher.stop)
self.list_json = lister_patcher.start()
self.list_json.return_value = [1, 2, 3]
self.api_mock = utils.ComputeApiMock('alpha').Start()
self.addCleanup(self.api_mock.Stop)
resource_registry = resources.REGISTRY.Clone()
resource_registry.RegisterApiByName('compute', 'v1')
project = resource_registry.Parse(
'https://compute.googleapis.com/compute/alpha/projects/lister-project')
frontend = lister._Frontend('filter', 123,
lister.AllScopes([project], True, True))
instances_lister = lister.MultiScopeLister(
self.api_mock.adapter,
aggregation_service=self.api_mock.adapter.apitools_client.instances,
return_partial_success=True)
result = list(instances_lister(frontend))
self.assertListEqual(result, [1, 2, 3])
self.list_json.assert_called_once_with(
requests=[
(self.api_mock.adapter.apitools_client.instances, 'AggregatedList',
self.api_mock.adapter.messages
.ComputeInstancesAggregatedListRequest(
filter='filter',
maxResults=123,
project='lister-project',
includeAllScopes=True,
returnPartialSuccess=True))
],
http=self.api_mock.adapter.apitools_client.http,
batch_url=self.api_mock.adapter.batch_url,
errors=[])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instanceGroupManagers,
regional_service=client.apitools_client.regionInstanceGroupManagers,
aggregation_service=client.apitools_client.instanceGroupManagers)
migs = lister.Invoke(request_data, list_implementation)
(self._had_errors,
results) = managed_instance_groups_utils.AddAutoscaledPropertyToMigs(
list(migs), client, holder.resources)
return results
def SetUp(self):
self.SelectApi(self.api_version)
self.api_mock = utils.ComputeApiMock(self.api_version).Start()
self.addCleanup(self.api_mock.Stop)
# os-inventory list implementation always uses this implementation
self.implementation = lister.MultiScopeLister(
self.api_mock.adapter,
zonal_service=self.api_mock.adapter.apitools_client.instances,
aggregation_service=self.api_mock.adapter.apitools_client.instances
)
if self.api_version == 'v1':
self.instances = test_resources.INSTANCES_V1
elif self.api_version == 'beta':
self.instances = test_resources.INSTANCES_BETA
elif self.api_version == 'alpha':
self.instances = test_resources.INSTANCES_ALPHA
else:
raise ValueError(
'api_version must be \'v1\', \'beta\' or \'alpha\', got [{0}]'
.format(self.api_version))
def testGlobalList(self):
lister_patcher = mock.patch(
'googlecloudsdk.api_lib.compute.request_helper.ListJson',
autospec=True)
self.addCleanup(lister_patcher.stop)
self.list_json = lister_patcher.start()
self.list_json.return_value = [1, 2, 3]
self.api_mock = utils.ComputeApiMock('v1').Start()
self.addCleanup(self.api_mock.Stop)
resource_registry = resources.REGISTRY.Clone()
resource_registry.RegisterApiByName('compute', 'v1')
project = resource_registry.Parse(
'https://compute.googleapis.com/compute/v1/projects/lister-project')
frontend = lister._Frontend('filter', 123,
lister.GlobalScope([project]))
zones_lister = lister.MultiScopeLister(
self.api_mock.adapter,
global_service=self.api_mock.adapter.apitools_client.zones)
result = list(zones_lister(frontend))
self.assertListEqual(result, [1, 2, 3])
self.list_json.assert_called_once_with(
requests=[(self.api_mock.adapter.apitools_client.zones, 'List',
self.api_mock.adapter.messages.ComputeZonesListRequest(
filter='filter',
maxResults=123,
project='lister-project'))],
http=self.api_mock.adapter.apitools_client.http,
batch_url=self.api_mock.adapter.batch_url,
errors=[])
def testDeepcopy(self):
global_lister = lister.MultiScopeLister(
'client', global_service='global_service')
self.assertEqual(global_lister, copy.deepcopy(global_lister))
