def Run(self, args):
"""List available routes."""
conn_context = connection_context.GetConnectionContext(
args, flags.Product.RUN, self.ReleaseTrack())
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return commands.SortByName(client.ListRoutes(namespace_ref))
def Run(self, args):
"""List available routes."""
if args.uri:
raise flags.ArgumentError('--uri flag is not supported for this resource')
conn_context = connection_context.GetConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
return client.ListRoutes(namespace_ref)
def Run(self, args):
"""List available revisions."""
service_name = args.service
conn_context = connection_context.GetConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return client.ListRevisions(namespace_ref, service_name)
def Run(self, args):
"""List available domain mappings."""
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.RUN)
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return commands.SortByName(client.ListDomainMappings(namespace_ref))
def _SetInvokerPermissions(args, function, is_new_function):
"""Add the IAM binding for the invoker role on the Cloud Run service, if applicable.
Args:
args: argparse.Namespace, arguments that this command was invoked with
function: cloudfunctions_v2alpha_messages.Function, recently created or
updated GCF function
is_new_function: bool, true if the function is being created
Returns:
None
"""
service_ref_one_platform = resources.REGISTRY.ParseRelativeName(
function.serviceConfig.service,
_CLOUD_RUN_SERVICE_COLLECTION_ONE_PLATFORM)
# This condition will be truthy if the user provided either
# `--allow-unauthenticated` or `--no-allow-unauthenticated`. In other
# words, it is only falsey when neither of those two flags is provided.
if args.IsSpecified('allow_unauthenticated'):
allow_unauthenticated = args.allow_unauthenticated
else:
if is_new_function:
allow_unauthenticated = console_io.PromptContinue(prompt_string=(
'Allow unauthenticated invocations of new function [{}]?'.
format(args.NAME)),
default=False)
else:
# The function already exists, and the user didn't request any change to
# the permissions. There is nothing to do in this case.
return
run_connection_context = connection_context.RegionalConnectionContext(
service_ref_one_platform.locationsId,
global_methods.SERVERLESS_API_NAME,
global_methods.SERVERLESS_API_VERSION)
with serverless_operations.Connect(run_connection_context) as operations:
service_ref_k8s = resources.REGISTRY.ParseRelativeName(
'namespaces/{}/services/{}'.format(
properties.VALUES.core.project.GetOrFail(),
service_ref_one_platform.Name()),
_CLOUD_RUN_SERVICE_COLLECTION_K8S)
if allow_unauthenticated:
operations.AddOrRemoveIamPolicyBinding(
service_ref_k8s,
add_binding=True,
member=serverless_operations.
ALLOW_UNAUTH_POLICY_BINDING_MEMBER,
role=serverless_operations.ALLOW_UNAUTH_POLICY_BINDING_ROLE)
elif not is_new_function:
operations.AddOrRemoveIamPolicyBinding(
service_ref_k8s,
add_binding=False,
member=serverless_operations.
ALLOW_UNAUTH_POLICY_BINDING_MEMBER,
role=serverless_operations.ALLOW_UNAUTH_POLICY_BINDING_ROLE)
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):
"""Create a domain mapping."""
# 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 platforms.GetPlatform() !=
platforms.PLATFORM_MANAGED else None))
domain_mapping_ref = args.CONCEPTS.domain.Parse()
changes = [
config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack())
]
# Check if the provided domain has already been verified
# if mapping to a non-CRoGKE service
if platforms.GetPlatform() == platforms.PLATFORM_MANAGED:
client = global_methods.GetServerlessClientInstance()
all_domains = global_methods.ListVerifiedDomains(client)
# If not already verified, explain and error out
if all(d.id not in domain_mapping_ref.Name() for d in all_domains):
if not all_domains:
domains_text = 'You currently have no verified domains.'
else:
domains = ['* {}'.format(d.id) for d in all_domains]
domains_text = ('Currently verified domains:\n{}'.format(
'\n'.join(domains)))
raise exceptions.DomainMappingCreationError(
'The provided domain does not appear to be verified '
'for the current account so a domain mapping '
'cannot be created. Visit [{help}] for more information.'
'\n{domains}'.format(help=DOMAIN_MAPPINGS_HELP_DOCS_URL,
domains=domains_text))
with serverless_operations.Connect(conn_context) as client:
try:
mapping = client.CreateDomainMapping(domain_mapping_ref,
args.service, changes,
args.force_override)
except exceptions.DomainMappingAlreadyExistsError as e:
if console_io.CanPrompt() and console_io.PromptContinue(
('This domain is already being used as a mapping elsewhere. '
'The existing mapping can be overriden by passing '
'`--force-override` or by continuing at the prompt below.'
),
prompt_string='Override the existing mapping'):
deletion.Delete(domain_mapping_ref,
client.GetDomainMapping,
client.DeleteDomainMapping,
async_=False)
mapping = client.CreateDomainMapping(
domain_mapping_ref, args.service, changes, True)
else:
raise e
for record in mapping.records:
record.name = record.name or mapping.route_name
return mapping.records
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 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.GetConfigurationChanges(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):
"""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):
"""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):
"""List executions of a job."""
job_name = args.job
namespace_ref = args.CONCEPTS.namespace.Parse()
conn_context = connection_context.GetConnectionContext(
args, flags.Product.RUN, self.ReleaseTrack())
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return self._SortExecutions(
client.ListExecutions(namespace_ref, job_name))
def Run(self, args):
"""Obtain details about a given route."""
conn_context = connection_context.GetConnectionContext(args)
route_ref = args.CONCEPTS.route.Parse()
with serverless_operations.Connect(conn_context) as client:
conf = client.GetRoute(route_ref)
if not conf:
raise flags.ArgumentError('Cannot find route [{}]'.format(
route_ref.routesId))
return conf
def Run(self, args):
"""Obtain details about a given service."""
conn_context = connection_context.GetConnectionContext(args)
service_ref = flags.GetService(args)
with serverless_operations.Connect(conn_context) as client:
serv = client.GetService(service_ref)
if not serv:
raise flags.ArgumentError('Cannot find service [{}]'.format(
service_ref.servicesId))
return serv
def Run(self, args):
"""Update configuration information about the service.
Does not change the running code.
Args:
args: Args!
"""
changes = flags.GetConfigurationChanges(args)
endpoint_visibility = flags.GetEndpointVisibility(args)
allow_unauth = flags.GetAllowUnauthenticated(args)
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`?')
conn_context = connection_context.GetConnectionContext(args)
service_ref = flags.GetService(args)
with serverless_operations.Connect(conn_context) as client:
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 = (
'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=url)
pretty_print.Success(msg)
def Run(self, args):
"""Obtain details about a given configuration."""
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.RUN)
configuration_ref = args.CONCEPTS.configuration.Parse()
with serverless_operations.Connect(conn_context) as client:
conf = client.GetConfiguration(configuration_ref)
if not conf:
raise flags.ArgumentError('Cannot find configuration [{}]'.format(
configuration_ref.configurationsId))
return conf
def Run(self, args):
"""Describe a domain mapping."""
conn_context = connection_context.GetConnectionContext(args)
domain_mapping_ref = args.CONCEPTS.domain.Parse()
with serverless_operations.Connect(conn_context) as client:
domain_mapping = client.GetDomainMapping(domain_mapping_ref)
if not domain_mapping:
raise flags.ArgumentError(
'Cannot find domain mapping for domain name [{}]'.format(
domain_mapping_ref.domainmappingsId))
return domain_mapping
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.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`, '
'`--image`?')
changes.append(
config_changes.SetLaunchStageAnnotationChange(self.ReleaseTrack()))
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)
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):
"""Show details about a revision."""
conn_context = connection_context.GetConnectionContext(args)
revision_ref = args.CONCEPTS.revision.Parse()
with serverless_operations.Connect(conn_context) as client:
wrapped_revision = client.GetRevision(revision_ref)
if not wrapped_revision:
raise flags.ArgumentError('Cannot find revision [{}]'.format(
revision_ref.revisionsId))
return wrapped_revision
def Run(self, args):
"""List tasks of a job execution."""
execution_ref = args.CONCEPTS.execution.Parse()
conn_context = connection_context.GetConnectionContext(
args, flags.Product.RUN, self.ReleaseTrack())
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
ret = client.ListTasks(execution_ref.Parent(),
execution_ref.Name(), args.filter_flags
or None)
return sorted(ret, key=lambda x: x.index)
def Run(self, args):
"""Obtain details about a given service."""
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:
serv = client.GetService(service_ref)
if not serv:
raise exceptions.ArgumentError('Cannot find service [{}]'.format(
service_ref.servicesId))
return serv
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):
"""Delete a service."""
conn_context = connection_context.GetConnectionContext(args)
service_ref = flags.GetService(args)
console_io.PromptContinue(
message='Service [{service}] will be deleted.'.format(
service=service_ref.servicesId),
throw_if_unattended=True,
cancel_on_no=True)
with serverless_operations.Connect(conn_context) as client:
client.DeleteService(service_ref)
log.DeletedResource(service_ref.servicesId, 'service')
def Run(self, args):
"""List available services."""
if args.uri:
raise flags.ArgumentError(
'--uri flag is not supported for this resource')
if not flags.IsGKE(args) and not getattr(args, 'region', None):
locations_ref = args.CONCEPTS.region.Parse()
return global_methods.ListServices(locations_ref.RelativeName())
else:
conn_context = connection_context.GetConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
return client.ListServices(namespace_ref)
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 a revision."""
conn_context = connection_context.GetConnectionContext(args)
revision_ref = args.CONCEPTS.revision.Parse()
console_io.PromptContinue(
message='Revision [{}] will be deleted.'.format(
revision_ref.revisionsId),
throw_if_unattended=True,
cancel_on_no=True)
with serverless_operations.Connect(conn_context) as client:
client.DeleteRevision(revision_ref)
log.DeletedResource(revision_ref.revisionsId, 'revision')
def Run(self, args):
"""List available 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 platforms.GetPlatform() !=
platforms.PLATFORM_MANAGED else None))
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return commands.SortByName(
client.ListDomainMappings(namespace_ref))
def Run(self, args):
"""List available revisions."""
service_name = args.service
conn_context = connection_context.GetConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with serverless_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
if not flags.IsManaged(args):
location_msg = ' in [{}]'.format(conn_context.cluster_location)
log.status.Print('For cluster [{cluster}]{zone}:'.format(
cluster=conn_context.cluster_name,
zone=location_msg
if conn_context.cluster_location else ''))
return client.ListRevisions(namespace_ref, service_name)
def Run(self, args):
"""Delete an execution."""
conn_context = connection_context.GetConnectionContext(
args, flags.Product.RUN, self.ReleaseTrack())
ex_ref = args.CONCEPTS.execution.Parse()
console_io.PromptContinue(
message='Execution [{}] will be deleted.'.format(ex_ref.executionsId),
throw_if_unattended=True,
cancel_on_no=True)
with serverless_operations.Connect(conn_context) as client:
client.DeleteExecution(ex_ref)
log.DeletedResource(ex_ref.executionsId, 'execution')
