def testEq(self):
client = object()
service = object()
global_lister1 = lister.GlobalLister(client, service)
global_lister2 = lister.GlobalLister(client, service)
self.assertEqual(global_lister1, global_lister2)
self.assertEqual(hash(global_lister1), hash(global_lister2))
def testNeq(self):
client1 = object()
client2 = object()
service = object()
global_lister1 = lister.GlobalLister(client1, service)
global_lister2 = lister.GlobalLister(client2, service)
self.assertNotEqual(global_lister1, global_lister2)
def testBatchList(self):
lister_patcher = mock.patch(
'googlecloudsdk.api_lib.compute.lister.GetGlobalResourcesDicts',
autospec=True)
self.addCleanup(lister_patcher.stop)
self.mock_get_global_resources = lister_patcher.start()
self.mock_get_global_resources.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(
self.Project(), collection='compute.projects')
frontend = lister._Frontend('filter', 123, lister.GlobalScope([project]))
global_lister = lister.GlobalLister(self.api_mock.adapter, 'service')
result = list(global_lister(frontend))
self.assertListEqual(result, [1, 2, 3])
self.mock_get_global_resources.assert_called_once_with(
service='service',
project=self.Project(),
filter_expr='filter',
http=self.api_mock.adapter.apitools_client.http,
batch_url=self.api_mock.adapter.batch_url,
errors=[])
def WarnIfSettingNonExistentRegionZone(prop, zonal=True):
"""Warn if setting 'compute/region' or 'compute/zone' to wrong value."""
zonal_msg = ('{} is not a valid zone. Run `gcloud compute zones list` to '
'get all zones.'.format(prop))
regional_msg = (
'{} is not a valid region. Run `gcloud compute regions list`'
'to get all regions.'.format(prop))
holder = base_classes.ComputeApiHolder(base.ReleaseTrack.GA)
client = holder.client
# pylint: disable=protected-access
request_data = lister._Frontend(
None, None,
lister.GlobalScope([
holder.resources.Parse(properties.VALUES.core.project.GetOrFail(),
collection='compute.projects')
]))
list_implementation = lister.GlobalLister(
client, client.apitools_client.zones
if zonal else client.apitools_client.regions)
try:
response = lister.Invoke(request_data, list_implementation)
zones = [i['name'] for i in list(response)]
if prop not in zones:
log.warning(zonal_msg if zonal else regional_msg)
except (lister.ListException, apitools_exceptions.HttpError,
c_store.NoCredentialsForAccountException,
api_lib_util_exceptions.HttpException):
log.warning('Property validation for compute/{} was skipped.'.format(
'zone' if zonal else 'region'))
def _Run(args, holder):
"""Issues requests necessary to list Target gRPC Proxies."""
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.targetGrpcProxies)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.httpsHealthChecks)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(
args, holder.resources, client.messages.PublicAdvertisedPrefix)
list_implementation = lister.GlobalLister(
client, client.apitools_client.publicAdvertisedPrefixes)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.networks)
return (networks_utils.AddModesForListFormat(resource)
for resource in lister.Invoke(request_data, list_implementation))
def Run(self, args):
log.status.Print(flags.LIST_NOTICE)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(client,
client.apitools_client.firewalls)
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 _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 testDeepcopy(self):
global_lister = lister.GlobalLister('client', 'service')
self.assertEqual(global_lister, copy.deepcopy(global_lister))
def testRepr(self):
global_lister = lister.GlobalLister('client', 'service')
# Python 2: u"GlobalLister(u'client', u'service')"
# Python 3: "GlobalLister('client', 'service')"
expected = 'GlobalLister({}, {})'.format(repr('client'), repr('service'))
self.assertEqual(repr(global_lister), expected)
