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))