def Run(self, args): """Create or Update service from YAML.""" conn_context = connection_context.GetConnectionContext( args, self.ReleaseTrack()) with serverless_operations.Connect(conn_context) as client: new_service = service.Service( messages_util.DictToMessageWithErrorCheck( args.FILE, client.messages_module.Service), client.messages_module) # If managed, namespace must match project (or will default to project if # not specified). # If not managed, namespace simply must not conflict if specified in # multiple places (or will default to "default" if not specified). namespace = args.CONCEPTS.namespace.Parse().Name() # From flag or default if new_service.metadata.namespace is not None: if (args.IsSpecified('namespace') and namespace != new_service.metadata.namespace): raise exceptions.ConfigurationError( 'Namespace specified in file does not match passed flag.') namespace = new_service.metadata.namespace project = properties.VALUES.core.project.Get() if flags.IsManaged(args) and namespace != project: raise exceptions.ConfigurationError( 'Namespace must be [{}] for Cloud Run (fully managed).'.format( project)) new_service.metadata.namespace = namespace changes = [config_changes.ReplaceServiceChange(new_service)] service_ref = resources.REGISTRY.Parse( new_service.metadata.name, params={'namespacesId': namespace}, collection='run.namespaces.services') original_service = client.GetService(service_ref) pretty_print.Info(deploy.GetStartDeployMessage(conn_context, service_ref)) deployment_stages = stages.ServiceStages() header = ( 'Deploying...' if original_service else 'Deploying new service...') with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: client.ReleaseService( service_ref, changes, tracker, asyn=args.async_, allow_unauthenticated=None, for_replace=True) if args.async_: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: pretty_print.Success(deploy.GetSuccessMessageForSynchronousDeploy( client, service_ref))
def Run(self, args): """Update the service resource. Different from `deploy` in that it can only update the service spec but no IAM or Cloud build changes. Args: args: Args! Returns: googlecloudsdk.api_lib.run.Service, the updated service """ changes = flags.GetServiceConfigurationChanges(args) if not changes or (len(changes) == 1 and isinstance( changes[0], config_changes.SetClientNameAndVersionAnnotationChange)): raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, `--timeout`, `--connectivity`, ' '`--image`?') changes.insert( 0, config_changes.DeleteAnnotationChange( k8s_object.BINAUTHZ_BREAKGLASS_ANNOTATION)) changes.append( config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack())) conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) service_ref = args.CONCEPTS.service.Parse() flags.ValidateResource(service_ref) with serverless_operations.Connect(conn_context) as client: service = client.GetService(service_ref) resource_change_validators.ValidateClearVpcConnector(service, args) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.spec_traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=False, include_route=has_latest) with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: service = client.ReleaseService(service_ref, changes, tracker, asyn=args.async_, prefetch=service) if args.async_: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service.name)) else: service = client.GetService(service_ref) pretty_print.Success( messages_util.GetSuccessMessageForSynchronousDeploy( service)) return service
def Run(self, args): """Execute a Job on Cloud Run.""" job_ref = args.CONCEPTS.job.Parse() flags.ValidateResource(job_ref) conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) with serverless_operations.Connect(conn_context) as operations: with progress_tracker.StagedProgressTracker( 'Creating execution...', stages.ExecutionStages(include_completion=args.wait), failure_message='Executing job failed', suppress_output=args.async_) as tracker: e = operations.RunJob(job_ref, args.wait, tracker, asyn=args.async_) if args.async_: pretty_print.Success( 'Execution [{{bold}}{execution}{{reset}}] is being' ' started asynchronously.'.format(execution=e.name)) else: operation = 'completed' if args.wait else 'started running' pretty_print.Success( 'Execution [{{bold}}{execution}{{reset}}] has ' 'successfully {operation}.'.format(execution=e.name, operation=operation)) log.status.Print( messages_util.GetExecutionCreatedMessage( self.ReleaseTrack(), e)) return e
def Run(self, args): """Update configuration information about the service. Does not change the running code. Args: args: Args! """ conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) if conn_context.supports_one_platform: flags.VerifyOnePlatformFlags(args) else: flags.VerifyGKEFlags(args) with serverless_operations.Connect(conn_context) as client: changes = flags.GetConfigurationChanges(args) endpoint_visibility = flags.GetEndpointVisibility(args) allow_unauth = None if conn_context.supports_one_platform: allow_unauth = flags.GetAllowUnauthenticated( args, client, service_ref) if not changes and endpoint_visibility is None and allow_unauth is None: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, `--timeout`, `--connectivity`, ' 'or `--allow-unauthenticated`?') deployment_stages = stages.ServiceStages(allow_unauth is not None) with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args. async) as tracker: client.ReleaseService(service_ref, changes, tracker, asyn=args. async, private_endpoint=endpoint_visibility, allow_unauthenticated=allow_unauth) if args. async: pretty_print.Success('Deploying asynchronously.') else: url = client.GetServiceUrl(service_ref) active_revs = client.GetActiveRevisions(service_ref) msg = ( '{{bold}}Service [{serv}] revision{plural} {rev_msg} is active' ' and serving traffic at{{reset}} {url}') rev_msg = ' '.join(['[{}]'.format(rev) for rev in active_revs]) msg = msg.format(serv=service_ref.servicesId, plural='s' if len(active_revs) > 1 else '', rev_msg=rev_msg, url=url) pretty_print.Success(msg)
def Run(self, args): """Deploy a container to Cloud Run.""" service_ref = flags.GetService(args) image = args.image # Build an image from source if source specified. if flags.FlagIsExplicitlySet(args, 'source'): # Create a tag for the image creation if image is None and not args.IsSpecified('config'): image = 'gcr.io/{projectID}/cloud-run-source-deploy/{service}:{tag}'.format( projectID=properties.VALUES.core.project.Get(required=True), service=service_ref.servicesId, tag=uuid.uuid4().hex) messages = cloudbuild_util.GetMessagesModule() build_config = submit_util.CreateBuildConfig( image, args.no_cache, messages, args.substitutions, args.config, args.IsSpecified('source'), False, args.source, args.gcs_source_staging_dir, args.ignore_file, args.gcs_log_dir, args.machine_type, args.disk_size) submit_util.Build(messages, args.async_, build_config) # Deploy a container with an image conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) config_changes = flags.GetConfigurationChanges(args) with serverless_operations.Connect(conn_context) as operations: image_change = config_changes_mod.ImageChange(image) changes = [image_change] if config_changes: changes.extend(config_changes) service = operations.GetService(service_ref) allow_unauth = GetAllowUnauth(args, operations, service_ref, service) pretty_print.Info(GetStartDeployMessage(conn_context, service_ref)) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.spec_traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=allow_unauth is not None, include_route=has_latest) header = 'Deploying...' if service else 'Deploying new service...' with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: operations.ReleaseService( service_ref, changes, tracker, asyn=args.async_, allow_unauthenticated=allow_unauth, prefetch=service) if args.async_: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: pretty_print.Success(GetSuccessMessageForSynchronousDeploy( operations, service_ref))
def Run(self, args): """Update configuration information about the service. Does not change the running code. Args: args: Args! """ changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, `--timeout`, `--connectivity`?') conn_context = connection_context.GetConnectionContext( args, product=connection_context.Product.RUN) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as client: service = client.GetService(service_ref) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=False, include_route=has_latest) with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: client.ReleaseService(service_ref, changes, tracker, asyn=args.async_, prefetch=service) if args.async_: pretty_print.Success('Deploying asynchronously.') else: service = client.GetService(service_ref) latest_ready = service.status.latestReadyRevisionName latest_percent_traffic = sum( target.percent for target in service.status.traffic if target.latestRevision or ( latest_ready and target.revisionName == latest_ready)) msg = ( 'Service [{{bold}}{serv}{{reset}}] ' 'revision [{{bold}}{rev}{{reset}}] ' 'has been deployed and is serving ' '{{bold}}{latest_percent_traffic}{{reset}} percent of traffic' ) if latest_percent_traffic: msg += (' at {{bold}}{url}{{reset}}') msg = msg.format(serv=service_ref.servicesId, rev=latest_ready, url=service.domain if 'domain' in dir(service) else service.url, latest_percent_traffic=latest_percent_traffic) pretty_print.Success(msg)
def Run(self, args): """Update configuration information about the service. Does not change the running code. Args: args: Args! """ changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, `--timeout`, `--connectivity`?') conn_context = connection_context.GetConnectionContext( args, product=connection_context.Product.RUN) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as client: service = client.GetService(service_ref) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=False, include_route=has_latest) with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: client.ReleaseService(service_ref, changes, tracker, asyn=args.async_, prefetch=service) if args.async_: pretty_print.Success('Deploying asynchronously.') else: service = client.GetService(service_ref) active_revs = client.GetActiveRevisions(service_ref) msg = ( 'Service [{{bold}}{serv}{{reset}}] revision{plural} {rev_msg} ' 'is active and serving traffic at {{bold}}{url}{{reset}}') rev_msg = ' '.join([ '[{{bold}}{}{{reset}}]'.format(rev) for rev in active_revs ]) msg = msg.format(serv=service_ref.servicesId, plural='s' if len(active_revs) > 1 else '', rev_msg=rev_msg, url=service.domain if 'domain' in dir(service) else service.url) pretty_print.Success(msg)
def Run(self, args): """Update the traffic split for the service. Args: args: Args! Returns: List of traffic.TrafficTargetStatus instances reflecting the change. """ conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) service_ref = args.CONCEPTS.service.Parse() flags.ValidateResource(service_ref) changes = flags.GetServiceConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No traffic configuration change requested.') changes.insert( 0, config_changes.DeleteAnnotationChange( k8s_object.BINAUTHZ_BREAKGLASS_ANNOTATION)) changes.append( config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack())) is_managed = platforms.GetPlatform() == platforms.PLATFORM_MANAGED with serverless_operations.Connect(conn_context) as client: deployment_stages = stages.UpdateTrafficStages() try: with progress_tracker.StagedProgressTracker( 'Updating traffic...', deployment_stages, failure_message='Updating traffic failed', suppress_output=args.async_) as tracker: client.UpdateTraffic(service_ref, changes, tracker, args.async_) except: serv = client.GetService(service_ref) if serv: resources = traffic_pair.GetTrafficTargetPairs( serv.spec_traffic, serv.status_traffic, is_managed, serv.status.latestReadyRevisionName, serv.status.url) display.Displayer( self, args, resources, display_info=args.GetDisplayInfo()).Display() raise if args.async_: pretty_print.Success('Updating traffic asynchronously.') else: serv = client.GetService(service_ref) resources = traffic_pair.GetTrafficTargetPairs( serv.spec_traffic, serv.status_traffic, is_managed, serv.status.latestReadyRevisionName, serv.status.url) return resources
def Run(self, args): """Update the traffic split for the service. Args: args: Args! Returns: List of traffic.TrafficTargetStatus instances reflecting the change. """ # TODO(b/143898356) Begin code that should be in Args resource_printer.RegisterFormatter( traffic_printer.TRAFFIC_PRINTER_FORMAT, traffic_printer.TrafficPrinter) args.GetDisplayInfo().AddFormat('traffic') # End code that should be in Args conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) service_ref = flags.GetService(args) changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No traffic configuration change requested.') is_managed = flags.GetPlatform() == flags.PLATFORM_MANAGED with serverless_operations.Connect(conn_context) as client: deployment_stages = stages.UpdateTrafficStages() try: with progress_tracker.StagedProgressTracker( 'Updating traffic...', deployment_stages, failure_message='Updating traffic failed', suppress_output=args.async_) as tracker: client.UpdateTraffic(service_ref, changes, tracker, args.async_) except: serv = client.GetService(service_ref) if serv: resources = traffic_pair.GetTrafficTargetPairs( serv.spec_traffic, serv.status_traffic, is_managed, serv.status.latestReadyRevisionName, serv.status.url) display.Displayer( self, args, resources, display_info=args.GetDisplayInfo()).Display() raise if args.async_: pretty_print.Success('Updating traffic asynchronously.') else: serv = client.GetService(service_ref) resources = traffic_pair.GetTrafficTargetPairs( serv.spec_traffic, serv.status_traffic, is_managed, serv.status.latestReadyRevisionName, serv.status.url) return resources
def Run(self, args): """Update environment variables.""" conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as client: changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags --update-env-vars, ' '--memory, or --concurrency?') client.ReleaseService(service_ref, changes, args. async) url = client.GetServiceUrl(service_ref) active_revs = client.GetActiveRevisions(service_ref) msg = ('{{bold}}Service [{serv}] revision{plural} {rev_msg} is active' ' and serving traffic at{{reset}} {url}') rev_msg = ' '.join(['[{}]'.format(rev) for rev in active_revs]) msg = msg.format(serv=service_ref.servicesId, plural='s' if len(active_revs) > 1 else '', rev_msg=rev_msg, url=url) pretty_print.Success(msg)
def Run(self, args): """Delete a Cloud Run Integration.""" integration_name = args.name conn_context = connection_context.GetConnectionContext( args, run_flags.Product.RUN_APPS, self.ReleaseTrack()) with run_apps_operations.Connect(conn_context) as client: with progress_tracker.StagedProgressTracker( 'Deleting Integration...', stages.IntegrationDeleteStages(), failure_message='Failed to delete integration.' ) as tracker: try: integration_type = client.DeleteIntegration( name=integration_name, tracker=tracker) except exceptions.IntegrationsOperationError as err: pretty_print.Info( messages_util.GetDeleteErrorMessage(integration_name)) raise err else: pretty_print.Info('') pretty_print.Success( messages_util.GetSuccessMessage( integration_type=integration_type, integration_name=integration_name, action='deleted'))
def Run(self, args): """Create or Update service from YAML.""" conn_context = connection_context.GetConnectionContext(args) if conn_context.supports_one_platform: flags.VerifyOnePlatformFlags(args) else: flags.VerifyGKEFlags(args) with serverless_operations.Connect(conn_context) as client: message_dict = yaml.load_path(args.FILE) new_service = service.Service( messages_util.DictToMessageWithErrorCheck( message_dict, client.messages_module.Service), client.messages_module) changes = [config_changes.ReplaceServiceChange(new_service)] service_ref = resources.REGISTRY.Parse( new_service.metadata.name, params={'namespacesId': new_service.metadata.namespace}, collection='run.namespaces.services') original_service = client.GetService(service_ref) pretty_print.Info( deploy.GetStartDeployMessage(conn_context, service_ref)) deployment_stages = stages.ServiceStages() header = ('Deploying...' if original_service else 'Deploying new service...') with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args. async) as tracker: client.ReleaseService(service_ref, changes, tracker, asyn=args. async, allow_unauthenticated=None, for_replace=True) if args. async: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: pretty_print.Success( deploy.GetSuccessMessageForSynchronousDeploy( client, service_ref))
def Run(self, args): """Deploy a container to Cloud Run.""" image = args.image conn_context = connection_context.GetConnectionContext( args, product=connection_context.Product.RUN) config_changes = flags.GetConfigurationChanges(args) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as operations: image_change = config_changes_mod.ImageChange(image) changes = [image_change] if config_changes: changes.extend(config_changes) service = operations.GetService(service_ref) allow_unauth = GetAllowUnauth(args, operations, service_ref, service) pretty_print.Info(GetStartDeployMessage(conn_context, service_ref)) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=allow_unauth is not None, include_route=has_latest) header = 'Deploying...' if service else 'Deploying new service...' with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: operations.ReleaseService(service_ref, changes, tracker, asyn=args.async_, allow_unauthenticated=allow_unauth, prefetch=service) if args.async_: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: pretty_print.Success( GetSuccessMessageForSynchronousDeploy( operations, service_ref))
def Run(self, args): """Delete domain mappings.""" conn_context = connection_context.GetConnectionContext(args) domain_mapping_ref = args.CONCEPTS.domain.Parse() with serverless_operations.Connect(conn_context) as client: client.DeleteDomainMapping(domain_mapping_ref) msg = """Mappings to [{domain}] now have been deleted.""".format( domain=domain_mapping_ref.domainmappingsId) pretty_print.Success(msg)
def Run(self, args): """Create a domain mapping.""" conn_context = connection_context.GetConnectionContext(args) domain_mapping_ref = args.CONCEPTS.domain.Parse() with serverless_operations.Connect(conn_context) as client: client.CreateDomainMapping(domain_mapping_ref, args.service) msg = """{domain} now maps to service [{serv}]""".format( domain=domain_mapping_ref.domainmappingsId, serv=args.service) pretty_print.Success(msg)
def Run(self, args): """Update configuration information about the service. Does not change the running code. Args: args: Args! """ conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as client: changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, or `--timeout`?') deployment_stages = stages.ServiceStages() with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args. async) as tracker: client.ReleaseService(service_ref, changes, tracker, args. async) if args. async: pretty_print.Success('Deploying asynchronously.') else: url = client.GetServiceUrl(service_ref) active_revs = client.GetActiveRevisions(service_ref) msg = ( '{{bold}}Service [{serv}] revision{plural} {rev_msg} is active' ' and serving traffic at{{reset}} {url}') rev_msg = ' '.join(['[{}]'.format(rev) for rev in active_revs]) msg = msg.format(serv=service_ref.servicesId, plural='s' if len(active_revs) > 1 else '', rev_msg=rev_msg, url=url) pretty_print.Success(msg)
def Run(self, args): """Deploy a container to Cloud Run.""" job_ref = args.CONCEPTS.job.Parse() flags.ValidateResource(job_ref) conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack(), version_override='v1alpha1') changes = flags.GetConfigurationChanges(args) changes.append( config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack())) with serverless_operations.Connect(conn_context) as operations: pretty_print.Info( messages_util.GetStartDeployMessage(conn_context, job_ref, 'job')) header_msg = 'Creating and {} job...'.format( 'running' if args.wait_for_completion else 'starting') with progress_tracker.StagedProgressTracker( header_msg, stages.JobStages(include_completion=args.wait_for_completion), failure_message='Job failed', suppress_output=args.async_) as tracker: job = operations.CreateJob( job_ref, changes, args.wait_for_completion, tracker, asyn=args.async_) if args.async_: pretty_print.Success('Job [{{bold}}{job}{{reset}}] is being created ' 'asynchronously.'.format(job=job.name)) else: job = operations.GetJob(job_ref) pretty_print.Success( 'Job [{{bold}}{job}{{reset}}] has successfully ' '{operation}.'.format( job=job.name, operation=('completed' if args.wait_for_completion else 'started running'))) return job
def Run(self, args): """Update the traffic split for the service. Args: args: Args! """ conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) if conn_context.supports_one_platform: flags.VerifyOnePlatformFlags(args) else: flags.VerifyGKEFlags(args) changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No traffic configuration change requested.') with serverless_operations.Connect(conn_context) as client: deployment_stages = stages.SetTrafficStages() with progress_tracker.StagedProgressTracker( 'Setting traffic...', deployment_stages, failure_message='Setting traffic failed', suppress_output=args. async) as tracker: client.SetTraffic(service_ref, changes, tracker, args. async, flags.IsManaged(args)) if args. async: pretty_print.Success('Setting traffic asynchronously.') else: serv = client.GetService(service_ref) splits = [ '{{bold}}{rev}{{reset}}={percent}'.format( rev='latest' if target.latestRevision else target.revisionName, percent=target.percent) for target in serv.spec.traffic ] msg = 'Traffic set to %s.' % ', '.join(splits) pretty_print.Success(msg)
def Run(self, args): """Update configuration information about the service. Does not change the running code. Args: args: Args! """ changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No configuration change requested. ' 'Did you mean to include the flags `--update-env-vars`, ' '`--memory`, `--concurrency`, `--timeout`, `--connectivity`?') conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as client: service = client.GetService(service_ref) has_latest = (service is None or traffic.LATEST_REVISION_KEY in service.spec_traffic) deployment_stages = stages.ServiceStages( include_iam_policy_set=False, include_route=has_latest) with progress_tracker.StagedProgressTracker( 'Deploying...', deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: client.ReleaseService(service_ref, changes, tracker, asyn=args.async_, prefetch=service) if args.async_: pretty_print.Success('Deploying asynchronously.') else: pretty_print.Success( messages_util.GetSuccessMessageForSynchronousDeploy( client, service_ref))
def Run(self, args): """Deploy a container to Cloud Run.""" image = args.image conn_context = connection_context.GetConnectionContext( args, self.ReleaseTrack()) config_changes = flags.GetConfigurationChanges(args) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as operations: image_change = config_changes_mod.ImageChange(image) changes = [image_change] if config_changes: changes.extend(config_changes) exists = operations.GetService(service_ref) allow_unauth = GetAllowUnauth(args, operations, service_ref, exists) pretty_print.Info(GetStartDeployMessage(conn_context, service_ref)) deployment_stages = stages.ServiceStages(allow_unauth is not None) header = 'Deploying...' if exists else 'Deploying new service...' with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: operations.ReleaseService(service_ref, changes, tracker, asyn=args.async_, allow_unauthenticated=allow_unauth) if args.async_: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: pretty_print.Success( GetSuccessMessageForSynchronousDeploy( operations, service_ref))
def Run(self, args): """Update the traffic split for the service. Args: args: Args! Returns: List of traffic.TrafficTargetStatus instances reflecting the change. """ conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) if conn_context.supports_one_platform: flags.VerifyOnePlatformFlags(args) else: flags.VerifyGKEFlags(args) changes = flags.GetConfigurationChanges(args) if not changes: raise exceptions.NoConfigurationChangeError( 'No traffic configuration change requested.') self._SetFormat(args) with serverless_operations.Connect(conn_context) as client: deployment_stages = stages.UpdateTrafficStages() try: with progress_tracker.StagedProgressTracker( 'Updating traffic...', deployment_stages, failure_message='Updating traffic failed', suppress_output=args.async_) as tracker: client.UpdateTraffic(service_ref, changes, tracker, args.async_) except: serv = client.GetService(service_ref) resources = traffic.GetTrafficTargetPairs( serv.spec.traffic, serv.status.traffic, flags.IsManaged(args), serv.status.latestReadyRevisionName) display.Displayer( self, args, resources, display_info=args.GetDisplayInfo()).Display() raise if args.async_: pretty_print.Success('Updating traffic asynchronously.') else: serv = client.GetService(service_ref) resources = traffic.GetTrafficTargetPairs( serv.spec.traffic, serv.status.traffic, flags.IsManaged(args), serv.status.latestReadyRevisionName) return resources
def Run(self, args): """Update a Job on Cloud Run.""" job_ref = args.CONCEPTS.job.Parse() flags.ValidateResource(job_ref) conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) changes = flags.GetJobConfigurationChanges(args) changes.append( config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack())) with serverless_operations.Connect(conn_context) as operations: pretty_print.Info( messages_util.GetStartDeployMessage(conn_context, job_ref, 'Updating', 'job')) header_msg = 'Updating job...' with progress_tracker.StagedProgressTracker( header_msg, stages.JobStages(), failure_message='Job failed to deploy', suppress_output=args.async_) as tracker: job = operations.UpdateJob(job_ref, changes, tracker, asyn=args.async_) if args.async_: pretty_print.Success( 'Job [{{bold}}{job}{{reset}}] is being updated ' 'asynchronously.'.format(job=job.name)) else: job = operations.GetJob(job_ref) pretty_print.Success( 'Job [{{bold}}{job}{{reset}}] has been successfully updated' .format(job=job.name)) log.status.Print( messages_util.GetRunJobMessage(self.ReleaseTrack(), job.name)) return job
def Run(self, args): """Deploy an app, function or container to Cloud Run.""" source_ref = flags.GetSourceRef(args.source, args.image) config_changes = flags.GetConfigurationChanges(args) conn_context = connection_context.GetConnectionContext(args) service_ref = flags.GetService(args) function_entrypoint = flags.GetFunction(args.function) msg = ('Deploying {dep_type} to service [{{bold}}{{service}}{{reset}}]' ' in {ns_label} [{{bold}}{{ns}}{{reset}}]') msg += conn_context.location_label if function_entrypoint: pretty_print.Info(msg.format( ns_label=conn_context.ns_label, dep_type='function [{bold}{function}{reset}]'), function=function_entrypoint, service=service_ref.servicesId, ns=service_ref.namespacesId) elif source_ref.source_type is source_ref.SourceType.IMAGE: pretty_print.Info(msg.format(ns_label=conn_context.ns_label, dep_type='container'), service=service_ref.servicesId, ns=service_ref.namespacesId) else: pretty_print.Info(msg.format(ns_label=conn_context.ns_label, dep_type='app'), service=service_ref.servicesId, ns=service_ref.namespacesId) with serverless_operations.Connect(conn_context) as operations: if not (source_ref.source_type is source_ref.SourceType.IMAGE or operations.IsSourceBranch()): raise exceptions.SourceNotSupportedError() new_deployable = operations.Detect(service_ref.Parent(), source_ref, function_entrypoint) operations.Upload(new_deployable) changes = [new_deployable] if config_changes: changes.extend(config_changes) operations.ReleaseService(service_ref, changes, asyn=args. async) url = operations.GetServiceUrl(service_ref) conf = operations.GetConfiguration(service_ref) msg = ('{{bold}}Service [{serv}] revision [{rev}] has been deployed' ' and is serving traffic at{{reset}} {url}') msg = msg.format(serv=service_ref.servicesId, rev=conf.status.latestReadyRevisionName, url=url) pretty_print.Success(msg)
def Run(self, args): """Delete domain mappings.""" # domains.cloudrun.com api group only supports v1alpha1 on clusters. conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack(), version_override=('v1alpha1' if flags.GetPlatform() != flags.PLATFORM_MANAGED else None)) domain_mapping_ref = args.CONCEPTS.domain.Parse() with serverless_operations.Connect(conn_context) as client: client.DeleteDomainMapping(domain_mapping_ref) msg = """Mappings to [{domain}] now have been deleted.""".format( domain=domain_mapping_ref.domainmappingsId) pretty_print.Success(msg)
def Run(self, args): """Creates a Cloud Run Integration.""" integration_type = args.type service = args.service input_name = args.name parameters = flags.GetParameters(args) flags.ValidateCreateParameters(integration_type, parameters) conn_context = connection_context.GetConnectionContext( args, run_flags.Product.RUN_APPS, self.ReleaseTrack()) with run_apps_operations.Connect(conn_context) as client: self._validateServiceNameAgainstIntegrations( client, integration_type=integration_type, service=service, integration_name=input_name) with progress_tracker.StagedProgressTracker( 'Creating new Integration...', stages.IntegrationStages(create=True), failure_message='Failed to create new integration.' ) as tracker: integration_name = client.CreateIntegration( tracker=tracker, integration_type=integration_type, parameters=parameters, service=service, name=input_name) resource_config = client.GetIntegration(integration_name) resource_status = client.GetIntegrationStatus(integration_name) pretty_print.Info('') pretty_print.Success( messages_util.GetSuccessMessage( integration_type=integration_type, integration_name=integration_name, action='created')) call_to_action = messages_util.GetCallToAction( integration_type, resource_config, resource_status) if call_to_action: pretty_print.Info('') pretty_print.Info(call_to_action) pretty_print.Info( messages_util.CheckStatusMessage(self.ReleaseTrack(), integration_name))
def Run(self, args): """Update a Cloud Run Integration.""" add_service = args.add_service remove_service = args.remove_service integration_name = args.name parameters = flags.GetParameters(args) conn_context = connection_context.GetConnectionContext( args, run_flags.Product.RUN_APPS, self.ReleaseTrack()) with run_apps_operations.Connect(conn_context) as client: with progress_tracker.StagedProgressTracker( 'Updating Integration...', stages.IntegrationStages(create=False), failure_message='Failed to update integration.' ) as tracker: client.UpdateIntegration(tracker=tracker, name=integration_name, parameters=parameters, add_service=add_service, remove_service=remove_service) resource_config = client.GetIntegration(integration_name) resource_status = client.GetIntegrationStatus(integration_name) resource_type = client.GetResourceTypeFromConfig(resource_config) integration_type = types_utils.GetIntegrationType(resource_type) pretty_print.Info('') pretty_print.Success( messages_util.GetSuccessMessage( integration_type=integration_type, integration_name=integration_name, action='updated')) call_to_action = messages_util.GetCallToAction( integration_type, resource_config, resource_status) if call_to_action: pretty_print.Info('') pretty_print.Info(call_to_action) pretty_print.Info( messages_util.CheckStatusMessage(self.ReleaseTrack(), integration_name))
def Run(self, args): """Deploy an app, function or container to Cloud Run.""" source_ref = flags.GetSourceRef(args.source, args.image) config_changes = flags.GetConfigurationChanges(args) conn_context = connection_context.GetConnectionContext(args) if (conn_context.supports_one_platform and getattr(args, 'connectivity', None)): raise exceptions.ConfigurationError( 'The `--endpoint=[internal|external]` flag ' 'is only supported with Cloud Run on GKE.') if (not conn_context.supports_one_platform and getattr(args, 'allow_unauthenticated', None)): raise exceptions.ConfigurationError( 'The `--allow-unauthenticated` flag ' 'is not supported with Cloud Run on GKE.') service_ref = flags.GetService(args) function_entrypoint = flags.GetFunction(args.function) msg = ('Deploying {dep_type} to {operator} ' 'service [{{bold}}{service}{{reset}}]' ' in {ns_label} [{{bold}}{ns}{{reset}}]') msg += conn_context.location_label if function_entrypoint: dep_type = 'function [{{bold}}{}{{reset}}]'.format( function_entrypoint) pretty_print.Info( msg.format(operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type=dep_type, function=function_entrypoint, service=service_ref.servicesId, ns=service_ref.namespacesId)) elif source_ref.source_type is source_ref.SourceType.IMAGE: pretty_print.Info( msg.format(operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type='container', service=service_ref.servicesId, ns=service_ref.namespacesId)) else: pretty_print.Info( msg.format(operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type='app', service=service_ref.servicesId, ns=service_ref.namespacesId)) with serverless_operations.Connect(conn_context) as operations: if not (source_ref.source_type is source_ref.SourceType.IMAGE or operations.IsSourceBranch()): raise exceptions.SourceNotSupportedError() new_deployable = operations.Detect(service_ref.Parent(), source_ref, function_entrypoint) operations.Upload(new_deployable) changes = [new_deployable] if config_changes: changes.extend(config_changes) if args.connectivity == 'internal': private_endpoint = True elif args.connectivity == 'external': private_endpoint = False else: private_endpoint = None deployment_stages = stages.ServiceStages() exists = operations.GetService(service_ref) if (not exists and not args.allow_unauthenticated and conn_context.supports_one_platform): if operations.CanAddIamPolicyBinding(service_ref): allow_unauth = console_io.PromptContinue( prompt_string=('Allow unauthenticated invocations ' 'to new service [{}]?'.format( service_ref.servicesId)), default=False) else: allow_unauth = False pretty_print.Info( 'This new service will require authentication to be invoked.' ) else: allow_unauth = False header = 'Deploying...' if exists else 'Deploying new service...' with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args. async) as tracker: operations.ReleaseService(service_ref, changes, tracker, asyn=args. async, private_endpoint=private_endpoint, allow_unauthenticated=allow_unauth or args.allow_unauthenticated) if args. async: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: url = operations.GetServiceUrl(service_ref) conf = operations.GetConfiguration(service_ref) msg = ('Service [{{bold}}{serv}{{reset}}] ' 'revision [{{bold}}{rev}{{reset}}] ' 'has been deployed and is serving traffic at ' '{{bold}}{url}{{reset}}') msg = msg.format(serv=service_ref.servicesId, rev=conf.status.latestReadyRevisionName, url=url) pretty_print.Success(msg)
def Run(self, args): """Create or Update service from YAML.""" conn_context = connection_context.GetConnectionContext( args, flags.Product.RUN, self.ReleaseTrack()) with serverless_operations.Connect(conn_context) as client: try: new_service = service.Service( messages_util.DictToMessageWithErrorCheck( args.FILE, client.messages_module.Service), client.messages_module) except messages_util.ScalarTypeMismatchError as e: exceptions.MaybeRaiseCustomFieldMismatch(e) # If managed, namespace must match project (or will default to project if # not specified). # If not managed, namespace simply must not conflict if specified in # multiple places (or will default to "default" if not specified). namespace = args.CONCEPTS.namespace.Parse().Name( ) # From flag or default if new_service.metadata.namespace is not None: if (args.IsSpecified('namespace') and namespace != new_service.metadata.namespace): raise exceptions.ConfigurationError( 'Namespace specified in file does not match passed flag.' ) namespace = new_service.metadata.namespace if flags.GetPlatform() == flags.PLATFORM_MANAGED: project = properties.VALUES.core.project.Get() project_number = projects_util.GetProjectNumber(project) if namespace != project and namespace != str( project_number): raise exceptions.ConfigurationError( 'Namespace must be project ID [{}] or quoted number [{}] for ' 'Cloud Run (fully managed).'.format( project, project_number)) new_service.metadata.namespace = namespace changes = [ config_changes.ReplaceServiceChange(new_service), config_changes.SetLaunchStageAnnotationChange( self.ReleaseTrack()) ] service_ref = resources.REGISTRY.Parse( new_service.metadata.name, params={'namespacesId': new_service.metadata.namespace}, collection='run.namespaces.services') service_obj = client.GetService(service_ref) pretty_print.Info( run_messages_util.GetStartDeployMessage( conn_context, service_ref, operation='Applying new configuration')) deployment_stages = stages.ServiceStages() header = ('Deploying...' if service_obj else 'Deploying new service...') with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args.async_) as tracker: service_obj = client.ReleaseService(service_ref, changes, tracker, asyn=args.async_, allow_unauthenticated=None, for_replace=True) if args.async_: pretty_print.Success( 'New configuration for [{{bold}}{serv}{{reset}}] is being applied ' 'asynchronously.'.format(serv=service_obj.name)) else: service_obj = client.GetService(service_ref) pretty_print.Success( 'New configuration has been applied to service ' '[{{bold}}{serv}{{reset}}].\n' 'URL: {{bold}}{url}{{reset}}'.format( serv=service_obj.name, url=service_obj.domain)) return service_obj
def Run(self, args): """Deploy a container to Cloud Run.""" image = args.image conn_context = connection_context.GetConnectionContext(args) config_changes = flags.GetConfigurationChanges(args) if conn_context.supports_one_platform: flags.VerifyOnePlatformFlags(args) else: flags.VerifyGKEFlags(args) service_ref = flags.GetService(args) with serverless_operations.Connect(conn_context) as operations: image_change = config_changes_mod.ImageChange(image) changes = [image_change] if config_changes: changes.extend(config_changes) endpoint_visibility = flags.GetEndpointVisibility(args) exists = operations.GetService(service_ref) allow_unauth = None if conn_context.supports_one_platform: allow_unauth = flags.GetAllowUnauthenticated( args, operations, service_ref, not exists) # Don't try to remove a policy binding from a service that doesn't exist if not exists and not allow_unauth: allow_unauth = None msg = ('Deploying {dep_type} to {operator} ' 'service [{{bold}}{service}{{reset}}]' ' in {ns_label} [{{bold}}{ns}{{reset}}]') msg += conn_context.location_label pretty_print.Info( msg.format(operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type='container', service=service_ref.servicesId, ns=service_ref.namespacesId)) deployment_stages = stages.ServiceStages(allow_unauth is not None) header = 'Deploying...' if exists else 'Deploying new service...' with progress_tracker.StagedProgressTracker( header, deployment_stages, failure_message='Deployment failed', suppress_output=args. async) as tracker: operations.ReleaseService(service_ref, changes, tracker, asyn=args. async, private_endpoint=endpoint_visibility, allow_unauthenticated=allow_unauth) if args. async: pretty_print.Success( 'Service [{{bold}}{serv}{{reset}}] is deploying ' 'asynchronously.'.format(serv=service_ref.servicesId)) else: url = operations.GetServiceUrl(service_ref) conf = operations.GetConfiguration(service_ref) msg = ('Service [{{bold}}{serv}{{reset}}] ' 'revision [{{bold}}{rev}{{reset}}] ' 'has been deployed and is serving traffic at ' '{{bold}}{url}{{reset}}') msg = msg.format(serv=service_ref.servicesId, rev=conf.status.latestReadyRevisionName, url=url) pretty_print.Success(msg)
def Run(self, args): """Deploy an app, function or container to Cloud Run.""" source_ref = flags.GetSourceRef(args.source, args.image) config_changes = flags.GetConfigurationChanges(args) conn_context = connection_context.GetConnectionContext(args) # pylint: disable=protected-access if (not isinstance(conn_context, connection_context._GKEConnectionContext) and getattr(args, 'endpoint', None)): raise exceptions.ConfigurationError( 'The `--endpoint=[internal|external]` flag ' 'is only supported with Cloud Run on GKE.') # pylint: enable=protected-access service_ref = flags.GetService(args) function_entrypoint = flags.GetFunction(args.function) msg = ('Deploying {dep_type} to {operator} ' 'service [{{bold}}{service}{{reset}}]' ' in {ns_label} [{{bold}}{ns}{{reset}}]') msg += conn_context.location_label if function_entrypoint: dep_type = 'function [{{bold}}{}{{reset}}]'.format(function_entrypoint) pretty_print.Info(msg.format( operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type=dep_type, function=function_entrypoint, service=service_ref.servicesId, ns=service_ref.namespacesId)) elif source_ref.source_type is source_ref.SourceType.IMAGE: pretty_print.Info(msg.format( operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type='container', service=service_ref.servicesId, ns=service_ref.namespacesId)) else: pretty_print.Info(msg.format( operator=conn_context.operator, ns_label=conn_context.ns_label, dep_type='app', service=service_ref.servicesId, ns=service_ref.namespacesId)) with serverless_operations.Connect(conn_context) as operations: if not (source_ref.source_type is source_ref.SourceType.IMAGE or operations.IsSourceBranch()): raise exceptions.SourceNotSupportedError() new_deployable = operations.Detect(service_ref.Parent(), source_ref, function_entrypoint) operations.Upload(new_deployable) changes = [new_deployable] if config_changes: changes.extend(config_changes) if args.endpoint == 'internal': private_endpoint = True elif args.endpoint == 'external': private_endpoint = False else: private_endpoint = None operations.ReleaseService(service_ref, changes, asyn=args.async, private_endpoint=private_endpoint) url = operations.GetServiceUrl(service_ref) conf = operations.GetConfiguration(service_ref) msg = ( 'Service [{{bold}}{serv}{{reset}}] revision [{{bold}}{rev}{{reset}}] ' 'has been deployed and is serving traffic at {{bold}}{url}{{reset}}') msg = msg.format( serv=service_ref.servicesId, rev=conf.status.latestReadyRevisionName, url=url) pretty_print.Success(msg)