def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) cluster_ref = args.CONCEPTS.cluster.Parse() request = dataproc.messages.DataprocProjectsRegionsClustersGetRequest( projectId=cluster_ref.projectId, region=cluster_ref.region, clusterName=cluster_ref.clusterName) cluster = dataproc.client.projects_regions_clusters.Get(request) # Filter out Dataproc-generated labels. clusters.DeleteGeneratedLabels(cluster, dataproc) schema_path = self.GetSchemaPath() if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=cluster, stream=stream, schema_path=schema_path) else: export_util.Export(message=cluster, stream=sys.stdout, schema_path=schema_path)
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client # Retrieve the specified compute instance. instance_ref = flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetInstanceZoneScopeLister(client)) request = client.messages.ComputeInstancesGetRequest( **instance_ref.AsDict()) instance = client.MakeRequests([(client.apitools_client.instances, 'Get', request)])[0] # Get JSON Schema for Compute Engine instances (located in # third_party/py/googlecloudsdk/schemas/...). schema_path = self.GetSchemaPath(for_help=False) # Write configuration data to either designated file or stdout. if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=instance, stream=stream, schema_path=schema_path) return log.status.Print('Exported [{}] to \'{}\'.'.format( instance.name, args.destination)) else: export_util.Export(message=instance, stream=sys.stdout, schema_path=schema_path)
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client (backend_services_utils. IsDefaultRegionalBackendServicePropertyNoneWarnOtherwise()) backend_service_ref = ( flags.GLOBAL_REGIONAL_BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client))) get_request = backend_services_utils.ComposeGetRequest( client, backend_service_ref) backend_service = client.MakeRequests([get_request])[0] if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=backend_service, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export(message=backend_service, stream=sys.stdout, schema_path=self.GetSchemaPath())
def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) template_ref = args.CONCEPTS.template.Parse() # Get specified version, or most recent version if no version arg provided. workflow_template = dataproc.GetRegionsWorkflowTemplate( template_ref, args.version) # Filter out OUTPUT_ONLY fields and resource identifying fields. Note this # needs to be kept in sync with v1 workflow_templates.proto. workflow_template.id = None workflow_template.name = None workflow_template.version = None workflow_template.createTime = None workflow_template.updateTime = None # We do not need to clear any fields from workflow_template.placement. # 1) Managed cluster: # a) cluster_name is really a name prefix, so it's okay that multiple # templates have the same value. # b) The server does not resolve OUTPUT_ONLY fields when storing a # workflow template, so cluster_config is fine as is. # 2) Cluster selector: there are no OUTPUT_ONLY or directly resource # identifying fields here. if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=workflow_template, stream=stream) else: export_util.Export(message=workflow_template, stream=sys.stdout)
def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) messages = dataproc.messages policy_ref = args.CONCEPTS.autoscaling_policy.Parse() request = messages.DataprocProjectsRegionsAutoscalingPoliciesGetRequest( name=policy_ref.RelativeName()) policy = dataproc.client.projects_regions_autoscalingPolicies.Get( request) schema_path = export_util.GetSchemaPath('dataproc', dataproc.api_version, 'AutoscalingPolicy', for_help=False) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=policy, stream=stream, schema_path=schema_path) else: # Print to stdout export_util.Export(message=policy, stream=sys.stdout, schema_path=schema_path)
def testImportAutoscalingPolicies_update_declineOverwrite(self): policy = self.MakeAutoscalingPolicy('fake-project', 'antarctica-north42', 'policy-1') # Write to a file so that we can use stdin to decline the prompt. Otherwise, # we wouldn't have a way to demarcate where the policy ends and declining # the prompt starts. file_name = os.path.join(self.temp_path, 'policy.yaml') with files.FileWriter(file_name) as stream: export_util.Export( message=policy, stream=stream, ) expected_request_policy = copy.deepcopy(policy) expected_request_policy.name = None self.mock_client.projects_regions_autoscalingPolicies.Create.Expect( self.messages. DataprocProjectsRegionsAutoscalingPoliciesCreateRequest( parent='projects/fake-project/regions/antarctica-north42', autoscalingPolicy=expected_request_policy, ), exception=self.MakeHttpError(status_code=409)) # Don't pass --quiet, and decline the prompt self.WriteInput('n\n') with self.AssertRaisesExceptionMatches( console_io.OperationCancelledError, 'Aborted by user.'): self.RunDataproc( 'autoscaling-policies import policy-1 --source {}'.format( file_name))
def _testImportAutoscalingPolicies_create(self, region=None, region_flag=''): if region is None: region = self.REGION policy = self.MakeAutoscalingPolicy('fake-project', region, 'policy-1') self.WriteInput(export_util.Export(message=policy)) expected_request_policy = copy.deepcopy(policy) expected_request_policy.name = None response_policy = copy.deepcopy(expected_request_policy) response_policy.name = ('projects/fake-project/regions/{0}/' 'autoscalingPolicies/policy-1'.format(region)) self.mock_client.projects_regions_autoscalingPolicies.Create.Expect( self.messages. DataprocProjectsRegionsAutoscalingPoliciesCreateRequest( parent='projects/fake-project/regions/{0}'.format(region), autoscalingPolicy=expected_request_policy, ), response=response_policy) result = self.RunDataproc( 'autoscaling-policies import policy-1 {0}'.format(region_flag)) self.AssertMessagesEqual(response_policy, result)
def testImportFromFile(self): target_grpc_proxy = copy.deepcopy(self._existing_target_grpc_proxy) target_grpc_proxy.description = 'changed' self.make_requests.side_effect = iter( [[test_resources.TARGET_GRPC_PROXIES_ALPHA[0]], [target_grpc_proxy]]) # Write the modified target_grpc_proxies to a file file_name = os.path.join(self.temp_path, 'temp-tgp.yaml') with files.FileWriter(file_name) as stream: export_util.Export(message=target_grpc_proxy, stream=stream) self.WriteInput('y\n') response = self.RunImport('{0} --source {1}'.format( self._resource_name, file_name)) self.CheckRequests([ (self._target_grpc_proxies_api, 'Get', self.messages.ComputeTargetGrpcProxiesGetRequest( project='my-project', targetGrpcProxy='target-grpc-proxy-1')) ], [(self._target_grpc_proxies_api, 'Patch', self.messages.ComputeTargetGrpcProxiesPatchRequest( project='my-project', targetGrpcProxy=self._resource_name, targetGrpcProxyResource=target_grpc_proxy))]) self.assertEqual(response, target_grpc_proxy)
def _testImportWorkflowTemplatesFromStdIn(self, region=None, region_flag=''): if region is None: region = self.REGION # Provided template does not have an id or a name. provided_template = self.MakeWorkflowTemplate(region=region) provided_template.id = None provided_template.name = None # The id is populated before we make the create request. expected_request = copy.deepcopy(provided_template) expected_request.id = self.WORKFLOW_TEMPLATE # The create response has the name populated. expected_response = copy.deepcopy(expected_request) expected_response.name = self.WorkflowTemplateName(region=region) self.WriteInput(export_util.Export(provided_template)) self.ExpectGetWorkflowTemplate( exception=self.MakeHttpError(status_code=404), region=region) self.ExpectCreateWorkflowTemplate(expected_request, expected_response, region=region) result = self.RunDataproc('workflow-templates import {0} {1}'.format( self.WORKFLOW_TEMPLATE, region_flag)) self.AssertMessagesEqual(expected_response, result)
def testImportWorkflowTemplatesUpdateExisting(self): # Provided template does not have an id or a name. provided_template = self.MakeWorkflowTemplate() provided_template.id = None provided_template.name = None get_response = self.MakeWorkflowTemplate() get_response.version = 1 # The id, name, and version are populated before we make the update request. expected_request = copy.deepcopy(provided_template) expected_request.id = self.WORKFLOW_TEMPLATE expected_request.name = self.WorkflowTemplateName() expected_request.version = 1 # Response has version incremented. expected_response = copy.deepcopy(expected_request) expected_response.version = 2 # Write test template to file. file_name = os.path.join(self.temp_path, 'template.yaml') with files.FileWriter(file_name) as stream: export_util.Export(message=provided_template, stream=stream) self.ExpectGetWorkflowTemplate(response=get_response) self.ExpectUpdateWorkflowTemplate(workflow_template=expected_request, response=expected_response) self.WriteInput('y\n') result = self.RunDataproc( 'workflow-templates import {0} --source {1}'.format( self.WORKFLOW_TEMPLATE, file_name)) self.AssertMessagesEqual(expected_response, result)
def testImportWorkflowTemplatesCreateNewWithRegion(self): # Set region property. properties.VALUES.dataproc.region.Set('us-test1') # Provided template does not have an id or a name. provided_template = self.MakeWorkflowTemplate() provided_template.id = None provided_template.name = None # The id is populated before we make the create request. expected_request = copy.deepcopy(provided_template) expected_request.id = self.WORKFLOW_TEMPLATE # The create response has the name populated. expected_response = copy.deepcopy(expected_request) expected_response.name = self.WorkflowTemplateName(region='us-test1') # Write test template to file. file_name = os.path.join(self.temp_path, 'template.yaml') with files.FileWriter(file_name) as stream: export_util.Export(message=provided_template, stream=stream) self.ExpectGetWorkflowTemplate( name=self.WorkflowTemplateName(region='us-test1'), exception=self.MakeHttpError(status_code=404)) parent = self.WorkflowTemplateParentName(region='us-test1') self.ExpectCreateWorkflowTemplate(workflow_template=expected_request, response=expected_response, parent=parent) result = self.RunDataproc( 'workflow-templates import {0} --source {1}'.format( self.WORKFLOW_TEMPLATE, file_name)) self.AssertMessagesEqual(expected_response, result)
def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) template_ref = args.CONCEPTS.template.Parse() # Get specified version, or most recent version if no version arg provided. workflow_template = dataproc.GetRegionsWorkflowTemplate( template_ref, args.version) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=workflow_template, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export(message=workflow_template, stream=sys.stdout, schema_path=self.GetSchemaPath())
def testPoliciesImport_update(self): with self.CreatedPolicy(self.autoscaling_policy_id): new_request = self.MakeImportableAutoscalingPolicy() new_request.basicAlgorithm.cooldownPeriod = '3600s' self.WriteInput(export_util.Export(message=new_request)) updated = self.RunDataproc( 'autoscaling-policies import --quiet {0}'.format( self.autoscaling_policy_id)) self.assertEqual(self.autoscaling_policy_id, updated.id) self.assertEqual('3600s', updated.basicAlgorithm.cooldownPeriod)
def CreatedPolicy(self, policy_id): policy = self.MakeImportableAutoscalingPolicy() self.WriteInput(export_util.Export(message=policy)) try: yield self.RunDataproc('autoscaling-policies import {0}'.format( policy_id)) finally: self.RunDataproc('autoscaling-policies delete {0} --quiet'.format( policy_id))
def testUpdateFromStdIn(self): """Tests updating an instance from stdin.""" self.WriteInput(export_util.Export(self._modified_instance)) self._RunUpdate('instance-1 --zone=zone-1 --project=my-project') self.CheckRequests([(self.compute.instances, 'Update', self.messages.ComputeInstancesUpdateRequest( instance='instance-1', zone='zone-1', project='my-project', instanceResource=self._modified_instance))])
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client forwarding_rule_ref = self.FORWARDING_RULE_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client)) forwarding_rule = utils.SendGetRequest(client, forwarding_rule_ref) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=forwarding_rule, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export(message=forwarding_rule, stream=sys.stdout, schema_path=self.GetSchemaPath())
def testImportAutoscalingPolicies_create_withoutRegionProperty(self): policy = self.MakeAutoscalingPolicy('fake-project', 'foobar', 'policy-1') self.WriteInput(export_util.Export(message=policy)) # No region is specified via flag or config. regex = r'Failed to find attribute \[region\]' with self.assertRaisesRegex(handlers.ParseError, regex): self.RunDataproc('autoscaling-policies import policy-1', set_region=False)
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) target_grpc_proxy_ref = self.TARGET_GRPC_PROXY_ARG.ResolveAsResource( args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL) target_grpc_proxy = _Describe(holder, target_grpc_proxy_ref) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export( message=target_grpc_proxy, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export( message=target_grpc_proxy, stream=sys.stdout, schema_path=self.GetSchemaPath())
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client url_map_ref = self.URL_MAP_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client)) url_map = url_maps_utils.SendGetRequest(client, url_map_ref) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=url_map, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export(message=url_map, stream=sys.stdout, schema_path=self.GetSchemaPath())
def testExportClustersToStdOut(self): cluster = self.MakeCluster() # Expected output has cluster-specific info cleared. expected_output = copy.deepcopy(cluster) expected_output.clusterName = None expected_output.projectId = None self.ExpectGetCluster(cluster) self.RunDataproc('clusters export {0}'.format(self.CLUSTER_NAME)) self.AssertOutputEquals(export_util.Export(expected_output))
def testImportBackendServiceFromStdIn(self): backend_service_ref = self.GetBackendServiceRef('my-backend-service') backend_service = copy.deepcopy(self._backend_services[0]) self.ExpectGetRequest(backend_service_ref=backend_service_ref, exception=http_error.MakeHttpError(code=404)) self.ExpectInsertRequest(backend_service_ref=backend_service_ref, backend_service=backend_service) self.WriteInput(export_util.Export(backend_service)) self.RunImport('my-backend-service --global')
def _Run(args, holder, url_map_arg, release_track): """Issues requests necessary to export URL maps.""" client = holder.client url_map_ref = url_map_arg.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client)) url_map = url_maps_utils.SendGetRequest(client, url_map_ref) codecs.RegisterL7TrafficControlCodecs(_GetApiVersion(release_track)) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=url_map, stream=stream, schema_path=_GetSchemaPath(release_track)) else: export_util.Export(message=url_map, stream=sys.stdout, schema_path=_GetSchemaPath(release_track))
def testImportFromStdInRegion(self): forwarding_rule_ref = self.GetForwardingRuleRef('fr-1', region='alaska') forwarding_rule = copy.deepcopy(self._forwarding_rules[0]) self.WriteInput(export_util.Export(forwarding_rule)) self.ExpectGetRequest(forwarding_rule_ref=forwarding_rule_ref, exception=http_error.MakeHttpError(code=404)) self.ExpectInsertRequest(forwarding_rule_ref, forwarding_rule=forwarding_rule) self.RunImport('fr-1 --region alaska')
def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) messages = dataproc.messages policy_ref = args.CONCEPTS.autoscaling_policy.Parse() request = messages.DataprocProjectsRegionsAutoscalingPoliciesGetRequest( name=policy_ref.RelativeName()) policy = dataproc.client.projects_regions_autoscalingPolicies.Get( request) # Filter out OUTPUT_ONLY fields and resource identifying fields. Note this # needs to be kept in sync with v1 autoscaling_policies.proto. policy.id = None policy.name = None if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=policy, stream=stream) else: # Print to stdout export_util.Export(message=policy, stream=sys.stdout)
def _Run(args, holder, target_http_proxy_arg, release_track): """Issues requests necessary to export target HTTP proxies.""" client = holder.client target_http_proxy_ref = target_http_proxy_arg.ResolveAsResource( args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL, scope_lister=compute_flags.GetDefaultScopeLister(client)) target_http_proxy = target_http_proxies_utils.SendGetRequest( client, target_http_proxy_ref) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=target_http_proxy, stream=stream, schema_path=_GetSchemaPath(release_track)) else: export_util.Export(message=target_http_proxy, stream=sys.stdout, schema_path=_GetSchemaPath(release_track))
def Run(self, args): dataproc = dp.Dataproc(self.ReleaseTrack()) cluster_ref = args.CONCEPTS.cluster.Parse() request = dataproc.messages.DataprocProjectsRegionsClustersGetRequest( projectId=cluster_ref.projectId, region=cluster_ref.region, clusterName=cluster_ref.clusterName) cluster = dataproc.client.projects_regions_clusters.Get(request) # Filter out Dataproc-generated labels and properties. clusters.DeleteGeneratedLabels(cluster, dataproc) clusters.DeleteGeneratedProperties(cluster, dataproc) RemoveNonImportableFields(cluster) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=cluster, stream=stream) else: export_util.Export(message=cluster, stream=sys.stdout)
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) helper = ssl_policies_utils.SslPolicyHelper(holder) client = holder.client ssl_policy_ref = self.SSL_POLICY_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client), default_scope=compute_scope.ScopeEnum.GLOBAL) ssl_policy = helper.Describe(ssl_policy_ref) if args.destination: with files.FileWriter(args.destination) as stream: export_util.Export(message=ssl_policy, stream=stream, schema_path=self.GetSchemaPath()) else: export_util.Export(message=ssl_policy, stream=sys.stdout, schema_path=self.GetSchemaPath())
def testReadAutoscalingPolicy_stdin(self): policy = self.MakeAutoscalingPolicy('cool-project', 'cool-region', 'cool-policy') self.WriteInput(export_util.Export(message=policy)) expected_policy = copy.deepcopy(policy) expected_policy.name = None policy_read = util.ReadAutoscalingPolicy( dataproc=self.dataproc_mock, policy_id='cool-policy', ) self.AssertMessagesEqual(expected_policy, policy_read)
def testExportWorkflowTemplatesWithVersion(self): workflow_template = self.MakeWorkflowTemplate(version=2, labels={'foo': 'bar'}) # Expected output has template-specific info cleared. expected_output = copy.deepcopy(workflow_template) expected_output.id = None expected_output.name = None expected_output.version = None self.ExpectGetWorkflowTemplate(version=2, response=workflow_template) self.RunDataproc('workflow-templates export {0} --version 2'.format( self.WORKFLOW_TEMPLATE)) self.AssertOutputEquals(export_util.Export(expected_output))
def testInstantiateFromFileWorkflowTemplatesAsync(self): workflow_template = self.MakeWorkflowTemplate() workflow_template.id = None workflow_template.name = None file_name = os.path.join(self.temp_path, 'template.yaml') with files.FileWriter(file_name) as stream: export_util.Export(message=workflow_template, stream=stream) self.ExpectWorkflowTemplatesInstantiateInline( workflow_template=workflow_template) self.RunDataproc( 'workflow-templates instantiate-from-file --file {0} --async'. format(file_name)) self.AssertOutputEquals('') self.AssertErrContains('Instantiating with operation [{0}].'.format( self.OperationName()))