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)
