class Describe(kuberun_command.KubeRunCommand, base.DescribeCommand):
"""Describes a domain mapping."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(Describe, cls).Args(parser)
parser.add_argument('domain',
help='The domain mapping to show details for.')
parser.display_info.AddFormat('yaml')
def BuildKubeRunArgs(self, args):
return [args.domain] + super(Describe, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'domain-mappings', 'describe']
def SuccessResult(self, out, args):
if out:
return domainmapping.DomainMapping(json.loads(out))
else:
raise exceptions.Error('Cannot find domain mapping [{}]'.format(
args.domain))
class List(kuberun_command.KubeRunCommandWithOutput, base.ListCommand):
"""Lists domain mappings in a Knative cluster."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlagGroup(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.URI_FLAG.RemoveFromParser(parser)
parser.display_info.AddFormat("""table(
{ready_column},
name:label=DOMAIN,
routeName:label=SERVICE)""".format(
ready_column=pretty_print.READY_COLUMN))
def Command(self):
return ['core', 'domain-mappings', 'list']
def FormatOutput(self, out, args):
if out:
json_object = json.loads(out)
return [domainmapping.DomainMapping(x) for x in json_object]
else:
raise exceptions.Error('Cannot list domain mappings')
class Delete(kuberun_command.KubeRunCommand, base.DeleteCommand):
"""Deletes a KubeRun service."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlag(),
flags.ClusterConnectionFlags(),
flags.AsyncFlag()
]
@classmethod
def Args(cls, parser):
super(Delete, cls).Args(parser)
parser.add_argument('service', help='The KubeRun service to delete.')
def SuccessResult(self, out, args):
log.DeletedResource(args.service, 'service')
def BuildKubeRunArgs(self, args):
return [args.service] + super(Delete, self).BuildKubeRunArgs(args)
def Run(self, args):
"""Delete a service."""
console_io.PromptContinue(
message='Service [{service}] will be deleted.'.format(
service=args.service),
throw_if_unattended=True,
cancel_on_no=True)
return super(Delete, self).Run(args)
def Command(self):
return ['core', 'services', 'delete']
class Update(kuberun_command.KubeRunCommand):
"""Updates a backend binding."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlag(),
flags.ClusterConnectionFlags(),
flags.MaxRateFlag(),
]
@classmethod
def Args(cls, parser):
super(Update, cls).Args(parser)
parser.add_argument(
'backend_binding',
help="""Name of the backend binding to update. This name
is the same as the Compute Engine backend service.""")
parser.display_info.AddFormat("""table(
name:label=NAME,
service:label=SERVICE,
ready:label=READY)""")
def BuildKubeRunArgs(self, args):
return [args.backend_binding] + super(Update, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'backend-bindings', 'update']
def SuccessResult(self, out, args):
if out:
return backendbinding.BackendBinding(json.loads(out))
else:
raise exceptions.Error('Could not update backend binding [{}]'.format(
args.backend_binding))
class Describe(kuberun_command.KubeRunCommandWithOutput, base.DescribeCommand):
"""Describes a Knative revision."""
detailed_help = _DETAILED_HELP
flags = [flags.ClusterConnectionFlags(), flags.NamespaceFlag()]
@classmethod
def Args(cls, parser):
super(Describe, cls).Args(parser)
parser.add_argument(
'revision', help='The Knative revision to show details for.')
resource_printer.RegisterFormatter(
revision_printer.REVISION_PRINTER_FORMAT,
revision_printer.RevisionPrinter,
hidden=True)
parser.display_info.AddFormat(revision_printer.REVISION_PRINTER_FORMAT)
def BuildKubeRunArgs(self, args):
return [args.revision] + super(Describe, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'revisions', 'describe']
def FormatOutput(self, out, args):
if out:
return revision.Revision(json.loads(out))
else:
raise exceptions.Error('Cannot find revision [{}]'.format(args.revision))
class Create(kuberun_command.KubeRunCommand, base.CreateCommand):
"""Creates a new KubeRun service."""
detailed_help = _DETAILED_HELP
flags = [
flags.ClusterConnectionFlags(),
flags.CommonServiceFlags(is_create=True),
flags.AsyncFlag(),
]
@classmethod
def Args(cls, parser):
super(Create, cls).Args(parser)
parser.add_argument(
'service',
help=
'ID of the service or fully qualified identifier for the service.')
def BuildKubeRunArgs(self, args):
return [args.service] + super(Create, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'services', 'create']
def SuccessResult(self, out, args):
return json.loads(out)
class List(kuberun_command.KubeRunCommandWithOutput, base.ListCommand):
"""Lists revisions in a Knative cluster."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlagGroup(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
columns = [
pretty_print.READY_COLUMN, 'name:label=REVISION',
'active.yesno(yes="yes", no="")',
'service_name:label=SERVICE:sort=1',
'creation_timestamp.date("%Y-%m-%d %H:%M:%S %Z"):'
'label=DEPLOYED:sort=2:reverse', 'author:label="DEPLOYED BY"'
]
parser.display_info.AddFormat('table({})'.format(','.join(columns)))
def Command(self):
return ['core', 'revisions', 'list']
def FormatOutput(self, out, args):
if out:
json_object = json.loads(out)
return [revision.Revision(x) for x in json_object]
else:
raise exceptions.Error('Cannot list revisions')
class Deploy(kuberun_command.KubeRunStreamingCommand, base.CreateCommand):
"""Deploy a Knative service."""
detailed_help = _DETAILED_HELP
flags = [
flags.ClusterConnectionFlags(),
flags.CommonServiceFlags(is_deploy=True),
flags.AsyncFlag(),
]
@classmethod
def Args(cls, parser):
super(Deploy, cls).Args(parser)
parser.add_argument(
'service',
help=
'ID of the service or fully qualified identifier for the service.')
def BuildKubeRunArgs(self, args):
return [args.service] + super(Deploy, self).BuildKubeRunArgs(args)
def OperationResponseHandler(self, response, args):
if response.failed:
log.error(response.stderr)
return None
if response.stderr:
log.status.Print(response.stderr)
return response.stdout
def Command(self):
return ['core', 'services', 'deploy']
class Delete(kuberun_command.KubeRunCommand, base.DeleteCommand):
"""Deletes a domain mapping."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(Delete, cls).Args(parser)
parser.add_argument(
'domain', help='The domain mapping to delete.')
def BuildKubeRunArgs(self, args):
return [args.domain] + super(Delete, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'domain-mappings', 'delete']
def OperationResponseHandler(self, response, args):
if response.failed:
raise exceptions.Error(response.stderr)
if response.stderr:
log.status.Print(response.stderr)
msg = """Mappings to [{domain}] now have been deleted.""".format(
domain=args.domain)
pretty_print.Success(msg)
return None
class Describe(kuberun_command.KubeRunCommand, base.DescribeCommand):
"""Describes a KubeRun service."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(Describe, cls).Args(parser)
parser.add_argument(
'service', help='The KubeRun service for which to show details.')
resource_printer.RegisterFormatter(
service_printer.SERVICE_PRINTER_FORMAT,
service_printer.ServicePrinter,
hidden=True)
parser.display_info.AddFormat(service_printer.SERVICE_PRINTER_FORMAT)
def BuildKubeRunArgs(self, args):
return [args.service] + super(Describe, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'services', 'describe']
def SuccessResult(self, out, args):
return json.loads(out)
class List(kuberun_command.KubeRunCommand, base.ListCommand):
"""Lists backend bindings in a KubeRun cluster."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlagGroup(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
parser.display_info.AddFormat("""table(
namespace:label=NAMESPACE,
name:label=BACKEND_SERVICE,
service:label=SERVICE,
ready:label=READY)""")
def Command(self):
return ['core', 'backend-bindings', 'list']
def SuccessResult(self, out, args):
if out:
json_object = json.loads(out)
return [backendbinding.BackendBinding(x) for x in json_object]
else:
raise exceptions.Error('Cannot list backend bindings')
class List(kuberun_command.KubeRunCommandWithOutput, base.ListCommand):
"""Lists services in a Knative cluster."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlagGroup(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
columns = [
pretty_print.READY_COLUMN,
'name:label=SERVICE',
'namespace:label=NAMESPACE',
'url',
'last_modifier:label="LAST DEPLOYED BY"',
'last_transition_time:label="LAST DEPLOYED AT"',
]
parser.display_info.AddFormat('table({})'.format(','.join(columns)))
def Command(self):
return ['core', 'services', 'list']
def FormatOutput(self, out, args):
if out:
json_object = json.loads(out)
return [service.Service(x) for x in json_object]
else:
raise exceptions.Error('Cannot list services')
class List(kuberun_command.KubeRunCommand, base.ListCommand):
"""Lists domain mappings in a KubeRun cluster."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlagGroup(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
pretty_print.AddReadyColumnTransform(parser)
parser.display_info.AddFormat("""table(
{ready_column},
metadata.name:label=DOMAIN,
spec.routeName:label=SERVICE)""".format(
ready_column=pretty_print.GetReadyColumn()))
def Command(self):
return ['core', 'domain-mappings', 'list']
def SuccessResult(self, out, args):
if out:
return [_AddAliases(x) for x in json.loads(out)]
else:
raise exceptions.Error('Cannot list domain mappings')
class Create(kuberun_command.KubeRunCommand):
"""Creates a backend binding."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlag(),
flags.ClusterConnectionFlags(),
flags.MaxRateFlag(True),
]
@classmethod
def Args(cls, parser):
super(Create, cls).Args(parser)
parser.add_argument(
'--service',
help=
'Name of the KubeRun service to bind to a Compute Engine backend service.',
required=True)
parser.add_argument(
'--backend-service',
help=
'Name of the Compute Engine backend service to bind to the KubeRun service.',
required=True)
parser.display_info.AddFormat("""table(
name:label=NAME,
service:label=SERVICE,
ready:label=READY)""")
def BuildKubeRunArgs(self, args):
return [
'--service',
args.service,
'--backend-service',
args.backend_service,
] + super(Create, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'backend-bindings', 'create']
def SuccessResult(self, out, args):
if out:
return backendbinding.BackendBinding(json.loads(out))
else:
raise exceptions.Error(
'Could not create backend binding [{}] for service [{}]'.
format(args.domain, args.service))
class Delete(kuberun_command.KubeRunCommand, base.DeleteCommand):
"""Deletes a Knative service."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlag(),
flags.ClusterConnectionFlags(),
flags.AsyncFlag()
]
@classmethod
def Args(cls, parser):
super(Delete, cls).Args(parser)
parser.add_argument('service',
help='The Knative service to delete.')
def OperationResponseHandler(self, response, args):
if response.failed:
log.error(response.stderr)
return None
if response.stderr:
log.status.Print(response.stderr)
log.status.Print('Service is successfully deleted.')
return None
def BuildKubeRunArgs(self, args):
return [args.service] + super(Delete, self).BuildKubeRunArgs(args)
def Run(self, args):
"""Delete a service."""
console_io.PromptContinue(
message='Service [{service}] will be deleted.'.format(
service=args.service),
throw_if_unattended=True,
cancel_on_no=True)
return super(Delete, self).Run(args)
def Command(self):
return ['core', 'services', 'delete']
class Delete(kuberun_command.KubeRunCommand, base.DeleteCommand):
"""Deletes a domain mapping."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(Delete, cls).Args(parser)
parser.add_argument('domain', help='The domain mapping to delete.')
def BuildKubeRunArgs(self, args):
return [args.domain] + super(Delete, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'domain-mappings', 'delete']
def SuccessResult(self, out, args):
msg = """Mappings to [{domain}] now have been deleted.""".format(
domain=args.domain)
pretty_print.Success(msg)
class UpdateTraffic(kuberun_command.KubeRunCommandWithOutput):
"""Updates the traffic settings of a Knative service."""
detailed_help = _DETAILED_HELP
flags = [
flags.ClusterConnectionFlags(),
flags.NamespaceFlag(),
flags.TrafficFlags(),
flags.AsyncFlag()
]
@classmethod
def Args(cls, parser):
super(UpdateTraffic, cls).Args(parser)
parser.add_argument(
'service',
help='Knative service for which to update the traffic settings.')
resource_printer.RegisterFormatter(
traffic_printer.TRAFFIC_PRINTER_FORMAT,
traffic_printer.TrafficPrinter,
hidden=True)
parser.display_info.AddFormat(traffic_printer.TRAFFIC_PRINTER_FORMAT)
def BuildKubeRunArgs(self, args):
return [args.service] + super(UpdateTraffic, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'services', 'update-traffic']
def FormatOutput(self, out, args):
if out:
svc = service.Service(json.loads(out))
return traffic_pair.GetTrafficTargetPairs(svc.spec_traffic,
svc.status_traffic,
svc.latest_ready_revision,
svc.url)
else:
raise exceptions.Error('Failed to update traffic for service [{}]'.format(
args.service))
class Delete(kuberun_command.KubeRunCommand, base.DeleteCommand):
"""Deletes a backend binding."""
detailed_help = _DETAILED_HELP
flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
@classmethod
def Args(cls, parser):
super(Delete, cls).Args(parser)
parser.add_argument(
'backend_binding',
help="""Name of the backend binding to delete. This name
is the same as the Compute Engine backend service.""")
def BuildKubeRunArgs(self, args):
return [args.backend_binding] + super(Delete,
self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'backend-bindings', 'delete']
def SuccessResult(self, out, args):
log.DeletedResource(args.backend_binding, 'backend binding')
class List(kuberun_command.KubeRunCommand, base.ListCommand):
"""Lists services in a KubeRun cluster."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlagGroup(),
flags.ClusterConnectionFlags(),
flags.ServiceListServiceFlag(),
]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
pretty_print.AddReadyColumnTransform(parser)
columns = [
pretty_print.GetReadyColumn(),
'metadata.name:label=SERVICE',
'metadata.namespace:label=NAMESPACE',
'status.url:label=URL',
('metadata.annotations["%s"]'
':label="LAST DEPLOYED BY":alias=LAST_DEPLOYED_BY' %
kubernetes_consts.ANN_LAST_MODIFIER),
('aliases.%s:label="LAST DEPLOYED AT"'
':alias=LAST_DEPLOYED_AT' % _ALIAS_KEY_LAST_DEPLOYED_AT),
]
parser.display_info.AddFormat('table({})'.format(','.join(columns)))
def Command(self):
return ['core', 'services', 'list']
def SuccessResult(self, out, args):
if out:
return [_AddAliases(x) for x in json.loads(out)]
else:
raise exceptions.Error('Cannot list services')
class List(kuberun_command.KubeRunCommand, base.ListCommand):
"""Lists revisions in a KubeRun cluster."""
detailed_help = _DETAILED_HELP
flags = [
flags.NamespaceFlagGroup(),
flags.ClusterConnectionFlags(),
flags.RevisionListServiceFlag()
]
@classmethod
def Args(cls, parser):
super(List, cls).Args(parser)
base.ListCommand._Flags(parser)
base.URI_FLAG.RemoveFromParser(parser)
pretty_print.AddReadyColumnTransform(parser)
columns = [
pretty_print.GetReadyColumn(), 'metadata.name:label=REVISION',
'aliases.%s.yesno(yes="yes", no="")' % _ALIAS_KEY_ACTIVE,
'metadata.labels["%s"]:label=SERVICE:sort=1' %
revision.SERVICE_LABEL,
('metadata.creationTimestamp.date("%Y-%m-%d %H:%M:%S %Z"):'
'label=DEPLOYED:sort=2:reverse'),
('metadata.annotations["%s"]:label="DEPLOYED BY"' %
revision.AUTHOR_ANNOTATION)
]
parser.display_info.AddFormat('table({})'.format(','.join(columns)))
def Command(self):
return ['core', 'revisions', 'list']
def SuccessResult(self, out, args):
if out:
return [_AddAliases(x) for x in json.loads(out)]
else:
raise exceptions.Error('Cannot list revisions')
parser.display_info.AddFormat("""table(
name:label=NAME,
type:label="RECORD TYPE",
rrdata:label=CONTENTS)""")
def BuildKubeRunArgs(self, args):
return ['--service', args.service, '--domain', args.domain] + super(
Create, self).BuildKubeRunArgs(args)
def Command(self):
return ['core', 'domain-mappings', 'create']
def SuccessResult(self, out, args):
if out:
mapping = json.loads(out)
status = mapping.get('status', {})
records = status.get('resourceRecords', [{}])
spec = mapping.get('spec', {})
default_name = spec.get('routeName')
for r in records:
r['name'] = r.get('name') or default_name
return records
else:
raise exceptions.Error(
'Could not map domain [{}] to service [{}]'.format(
args.domain, args.service))
Create.detailed_help = _DETAILED_HELP
Create.flags = [flags.NamespaceFlag(), flags.ClusterConnectionFlags()]
def Args(parser): flags.ClusterConnectionFlags().AddToParser(parser)
