def Run(self, args):
conn_context = connection_context.EventsConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
brokers = client.ListBrokers(namespace_ref.RelativeName())
return brokers
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return [crd for crd in source_crds if crd.event_types]
def Run(self, args):
conn_context = connection_context.EventsConnectionContext(args)
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return util.EventTypeFromTypeString(source_crds, args.event_type,
args.source)
def Run(self, args):
"""Executes when the user runs the describe command."""
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
trigger_ref = args.CONCEPTS.trigger.Parse()
with eventflow_operations.Connect(conn_context) as client:
trigger_obj = client.GetTrigger(trigger_ref)
source_obj = None
if trigger_obj is not None:
source_crds = client.ListSourceCustomResourceDefinitions()
source_obj_ref = trigger_obj.dependency
source_crd = next((s for s in source_crds
if s.source_kind == source_obj_ref.kind),
None)
if source_crd is not None:
source_ref = util.GetSourceRef(source_obj_ref.name,
source_obj_ref.namespace,
source_crd)
source_obj = client.GetSource(source_ref, source_crd)
if not trigger_obj:
raise exceptions.TriggerNotFound('Trigger [{}] not found.'.format(
trigger_ref.Name()))
if not source_obj:
log.warning('No matching event source for trigger [{}].'.format(
trigger_ref.Name()))
return SerializedTriggerAndSource(
trigger_obj.MakeSerializable(),
source_obj.MakeSerializable() if source_obj else None)
def Run(self, args):
"""Executes when the user runs the delete command."""
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
trigger_ref = args.CONCEPTS.trigger.Parse()
console_io.PromptContinue(
message='Trigger [{}] will be deleted.'.format(trigger_ref.Name()),
throw_if_unattended=True,
cancel_on_no=True)
with eventflow_operations.Connect(conn_context) as client:
# TODO(b/147308604): Don't delete source when Odin supports ownerRefs
if serverless_flags.GetPlatform() == serverless_flags.PLATFORM_MANAGED:
trigger_obj = client.GetTrigger(trigger_ref)
if trigger_obj is not None:
source_crds = client.ListSourceCustomResourceDefinitions()
source_ref, source_crd = util.GetSourceRefAndCrdForTrigger(
trigger_obj, source_crds)
if source_ref and source_crd:
# Delete the source before the trigger because we need the trigger
# to exist to be able to find the source. Otherwise, we could end up
# losing a reference to the source if trigger deletion succeeds but
# source deletion fails.
try:
client.DeleteSource(source_ref, source_crd)
except exceptions.SourceNotFound:
# Source could have been deleted but trigger deletion failed
# and this command was re-run, which is fine.
pass
client.DeleteTrigger(trigger_ref)
log.DeletedResource(trigger_ref.Name(), 'trigger')
def Run(self, args):
"""Executes when user runs the init command."""
if platforms.GetPlatform() == platforms.PLATFORM_MANAGED:
raise exceptions.UnsupportedArgumentError(
'This command is only available with Cloud Run for Anthos.')
kuberun_events_flags.ValidateAuthenticationFlags(args)
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
product_type = init_shared.determine_product_type(
client, args.authentication)
if not client.GetNamespace(namespace_ref):
client.CreateNamespace(namespace_ref)
if args.authentication == events_constants.AUTH_SECRETS:
client.CreateOrReplaceSourcesSecret(namespace_ref,
product_type)
log.status.Print(
'Initialized namespace [{}] for Cloud Run eventing with '
'secret {}'.format(namespace_ref.Name(),
anthosevents_operations.SOURCES_KEY))
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return [crd for crd in source_crds if crd.event_types]
def Run(self, args):
"""Executes when the user runs the describe command."""
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
trigger_ref = args.CONCEPTS.trigger.Parse()
with eventflow_operations.Connect(conn_context) as client:
trigger_obj = client.GetTrigger(trigger_ref)
source_obj = None
if trigger_obj is not None:
source_crds = client.ListSourceCustomResourceDefinitions()
source_ref, source_crd = util.GetSourceRefAndCrdForTrigger(
trigger_obj, source_crds)
if source_ref and source_crd:
source_obj = client.GetSource(source_ref, source_crd)
if not trigger_obj:
raise exceptions.TriggerNotFound(
'Trigger [{}] not found.'.format(trigger_ref.Name()))
if not source_obj:
log.warning('No matching event source for trigger [{}].'.format(
trigger_ref.Name()))
return SerializedTriggerAndSource(
trigger_obj.MakeSerializable(),
source_obj.MakeSerializable() if source_obj else None)
def Run(self, args):
"""Executes when the user runs the describe command."""
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
trigger_ref = args.CONCEPTS.trigger.Parse()
with eventflow_operations.Connect(conn_context) as client:
if client.IsCluster():
trigger_ref = resources.REGISTRY.Parse(
trigger_ref.RelativeName(),
collection=util.ANTHOS_TRIGGER_COLLECTION_NAME,
api_version=client.api_version)
trigger_obj = client.GetTrigger(trigger_ref)
source_obj = None
if trigger_obj is not None:
source_crds = client.ListSourceCustomResourceDefinitions()
source_ref, source_crd = util.GetSourceRefAndCrdForTrigger(
trigger_obj, source_crds, client.IsCluster())
if source_ref and source_crd:
source_obj = client.GetSource(source_ref, source_crd)
if not trigger_obj:
raise exceptions.TriggerNotFound('Trigger [{}] not found.'.format(
trigger_ref.Name()))
if not source_obj:
log.warning('No matching event source for trigger [{}].'.format(
trigger_ref.Name()))
return SerializedTriggerAndSource(
trigger_obj.MakeSerializable(),
source_obj.MakeSerializable() if source_obj else None)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return util.EventTypeFromTypeString(
source_crds, args.event_type, args.source)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return util.EventTypeFromTypeString(source_crds, args.event_type)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
return [crd for crd in source_crds if crd.event_types]
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
trigger_ref = args.CONCEPTS.trigger.Parse()
namespace_ref = trigger_ref.Parent()
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
event_type = util.EventTypeFromTypeString(source_crds, args.type)
source_obj = source.Source.New(client.client, namespace_ref.Name(),
event_type.crd.source_kind,
event_type.crd.source_api_category)
source_obj.name = _SOURCE_NAME_PATTERN.format(
trigger=trigger_ref.Name())
trigger_obj = client.GetTrigger(trigger_ref)
if trigger_obj is not None:
# If trigger already exists, validate it has the attributes we're trying
# to set right now.
try:
util.ValidateTrigger(trigger_obj, source_obj, event_type)
except AssertionError:
raise exceptions.TriggerCreationError(
'Trigger [{}] already exists with attributes not '
'matching this event type.'.format(trigger_obj.name))
# If the trigger has the right attributes, check if there's already
# a source that matches the attributes as well.
source_ref = util.GetSourceRef(
source_obj.name, source_obj.namespace, event_type.crd)
if client.GetSource(source_ref, event_type.crd) is not None:
raise exceptions.TriggerCreationError(
'Trigger [{}] already exists.'.format(trigger_obj.name))
parameters = events_flags.GetAndValidateParameters(args, event_type)
# Create the trigger and source
with progress_tracker.StagedProgressTracker(
'Initializing trigger...',
stages.TriggerSourceStages(),
failure_message='Trigger creation failed') as tracker:
client.CreateTriggerAndSource(
trigger_obj,
trigger_ref,
namespace_ref,
source_obj,
event_type,
parameters,
args.broker,
args.target_service,
tracker
)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
event_types = []
for crd in source_crds:
if not args.IsSpecified('source') or args.source == crd.source_kind:
event_types.extend(crd.event_types)
return event_types
def Run(self, args):
if serverless_flags.GetPlatform() == serverless_flags.PLATFORM_MANAGED:
raise exceptions.UnsupportedArgumentError(
'This command is only available with Cloud Run for Anthos.')
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
brokers = client.ListBrokers(namespace_ref.RelativeName())
return brokers
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, product=serverless_flags.Product.EVENTS)
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
triggers = client.ListTriggers(namespace_ref)
if args.target_service:
triggers = [t for t in triggers if t.subscriber == args.target_service]
return triggers
def Run(self, args):
conn_context = connection_context.EventsConnectionContext(args)
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
event_types = []
for crd in source_crds:
if not args.IsSpecified(
'source') or args.source == crd.source_kind:
event_types.extend(crd.event_types)
return event_types
def Run(self, args):
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.ConfigurationError(
'Triggers are not yet supported on the fully managed version '
'of Cloud Run.')
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
return client.ListTriggers(namespace_ref)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
event_types = []
for crd in source_crds:
if not args.category or args.category == crd.source_kind:
event_types.extend(crd.event_types)
return event_types
def testConnectAnthos(self):
mock_context = mock.Mock()
mock_context.__enter__ = mock.Mock(return_value=mock_context)
mock_context.__exit__ = mock.Mock(return_value=False)
mock_context.supports_one_platform = False
mock_context.region = None
with eventflow_operations.Connect(mock_context) as eventflow_client:
self.assertEqual(eventflow_client._client, self.mock_client)
self.assertEqual(eventflow_client._core_client, self.mock_client)
self.assertEqual(eventflow_client._crd_client, self.mock_client)
self.assertEqual(eventflow_client._op_client, self.mock_client)
self.assertIsNone(eventflow_client._region)
def Run(self, args):
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
with eventflow_operations.Connect(conn_context) as client:
source_crds = client.ListSourceCustomResourceDefinitions()
event_types = []
for crd in source_crds:
if not args.category or args.category == crd.source_kind:
event_types.extend(crd.event_types)
return event_types
def Run(self, args):
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
self.SetCompleteApiEndpoint(conn_context.endpoint)
triggers = client.ListTriggers(namespace_ref)
if args.target_service:
triggers = [t for t in triggers if t.subscriber == args.target_service]
return triggers
def Run(self, args):
"""Executes when the user runs the delete command."""
conn_context = connection_context.GetConnectionContext(
args, product=connection_context.Product.EVENTS)
trigger_ref = args.CONCEPTS.trigger.Parse()
console_io.PromptContinue(
message='Trigger [{}] will be deleted.'.format(trigger_ref.Name()),
throw_if_unattended=True,
cancel_on_no=True)
with eventflow_operations.Connect(conn_context) as client:
client.DeleteTrigger(trigger_ref)
log.DeletedResource(trigger_ref.Name(), 'trigger')
def Run(self, args):
"""Executes when the user runs the delete command."""
if serverless_flags.GetPlatform() == serverless_flags.PLATFORM_MANAGED:
raise exceptions.UnsupportedArgumentError(
'This command is only available with Cloud Run for Anthos.')
project = properties.VALUES.core.project.Get(required=True)
conn_context = connection_context.GetConnectionContext(
args, serverless_flags.Product.EVENTS, self.ReleaseTrack())
with eventflow_operations.Connect(conn_context) as client:
cloud_run_obj = client.GetCloudRun()
if cloud_run_obj is None:
pass
elif cloud_run_obj.eventing_enabled:
log.status.Print('Eventing already enabled.')
else:
tracker_stages = stages.EventingStages()
# Enable eventing
with progress_tracker.StagedProgressTracker(
'Enabling eventing...',
tracker_stages,
failure_message='Failed to enable eventing'
) as tracker:
response = client.UpdateCloudRunWithEventingEnabled()
# Wait for Operator to enable eventing
client.PollCloudRunResource(tracker)
log.status.Print('Enabled eventing successfully.')
if client.IsClusterInitialized():
console_io.PromptContinue(
message='This cluster has already been initialized.',
prompt_string='Would you like to re-run initialization?',
cancel_on_no=True)
_EnableMissingServices(project)
for sa_config in [
_CONTROL_PLANE_SERVICE_ACCOUNT_CONFIG,
_BROKER_SERVICE_ACCOUNT_CONFIG,
_SOURCES_SERVICE_ACCOUNT_CONFIG
]:
_ConfigureServiceAccount(sa_config, client, args)
client.MarkClusterInitialized()
log.status.Print(
_InitializedMessage(self.ReleaseTrack(),
conn_context.cluster_name))
def Run(self, args):
"""Executes when the user runs the describe command."""
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
trigger_ref = args.CONCEPTS.trigger.Parse()
with eventflow_operations.Connect(conn_context) as client:
trigger_obj = client.GetTrigger(trigger_ref)
if not trigger_obj:
raise exceptions.TriggerNotFound('Trigger [{}] not found.'.format(
trigger_ref.Name()))
return trigger_obj
def testConnectManaged(self):
region = 'us-central1'
mock_context = mock.Mock()
mock_context.__enter__ = mock.Mock(return_value=mock_context)
mock_context.__exit__ = mock.Mock(return_value=False)
mock_context.supports_one_platform = True
mock_context.region = region
with eventflow_operations.Connect(mock_context) as eventflow_client:
self.assertEqual(eventflow_client._client, self.mock_client)
self.assertIsNone(eventflow_client._core_client)
self.assertEqual(eventflow_client._crd_client, self.mock_client)
self.assertEqual(eventflow_client._op_client, self.mock_client)
self.assertEqual(eventflow_client._region, region)
def Run(self, args):
"""Executes when the user runs the describe command."""
conn_context = connection_context.EventsConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
broker_name = args.BROKER
broker_full_name = namespace_ref.RelativeName(
) + '/brokers/' + broker_name
with eventflow_operations.Connect(conn_context) as client:
broker_obj = client.GetBroker(broker_full_name)
if not broker_obj:
raise exceptions.BrokerNotFound(
'Broker [{}] not found.'.format(broker_name))
return broker_obj
def Run(self, args):
"""Executes when the user runs the delete command."""
conn_context = connection_context.GetConnectionContext(args)
if conn_context.supports_one_platform:
raise exceptions.UnsupportedArgumentError(
'Events are only available with Cloud Run for Anthos.')
trigger_ref = args.CONCEPTS.trigger.Parse()
console_io.PromptContinue(
message='Trigger [{}] will be deleted.'.format(trigger_ref.Name()),
throw_if_unattended=True,
cancel_on_no=True)
with eventflow_operations.Connect(conn_context) as client:
client.DeleteTrigger(trigger_ref)
log.DeletedResource(trigger_ref.Name(), 'trigger')
def Run(self, args):
"""Executes when the user runs the delete command."""
conn_context = connection_context.EventsConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
broker_name = args.BROKER
console_io.PromptContinue(
message='Broker [{}] will be deleted.'.format(broker_name),
throw_if_unattended=True,
cancel_on_no=True)
with eventflow_operations.Connect(conn_context) as client:
client.DeleteBroker(namespace_ref.Name(), broker_name)
log.DeletedResource(broker_name, 'broker')
def Run(self, args):
"""Executes when the user runs the delete command."""
if serverless_flags.GetPlatform() == serverless_flags.PLATFORM_MANAGED:
raise exceptions.UnsupportedArgumentError(
'This command is only available with Cloud Run for Anthos.')
if args.BROKER != _DEFAULT_BROKER_NAME:
raise exceptions.UnsupportedArgumentError(
'Only brokers named "default" may be created.')
conn_context = connection_context.GetConnectionContext(
args, product=serverless_flags.Product.EVENTS)
service_account_ref = resources.REGISTRY.Parse(
args.service_account,
params={'projectsId': '-'},
collection=core_iam_util.SERVICE_ACCOUNTS_COLLECTION)
namespace_ref = args.CONCEPTS.namespace.Parse()
secret_ref = resources.REGISTRY.Parse(
_DATA_PLANE_SECRET_NAME,
params={'namespacesId': namespace_ref.Name()},
collection='run.api.v1.namespaces.secrets',
api_version='v1')
# Validate the service account has the necessary roles
roles = iam_util.GetProjectRolesForServiceAccount(service_account_ref)
if not (_OWNER_ROLE in roles
or _DATA_PLANE_SECRET_MIN_REQUIRED_ROLES.issubset(roles)):
missing_roles = _DATA_PLANE_SECRET_MIN_REQUIRED_ROLES - roles
raise exceptions.ServiceAccountMissingRequiredPermissions(
'Service account [{}] does not have necessary role(s): {}'.
format(service_account_ref.Name(), ', '.join(missing_roles)))
with eventflow_operations.Connect(conn_context) as client:
if console_io.CanPrompt():
console_io.PromptContinue(
message='This will create a new key for the provided '
'service account.',
cancel_on_no=True)
_, key_ref = client.CreateOrReplaceServiceAccountSecret(
secret_ref, service_account_ref)
client.UpdateNamespaceWithLabels(namespace_ref, _INJECTION_LABELS)
log.status.Print('Created broker [{}] in namespace [{}] with '
'key [{}] for service account [{}].'.format(
args.BROKER, namespace_ref.Name(), key_ref.Name(),
service_account_ref.Name()))
