def TriggerSourceStages():
return [
progress_tracker.Stage('Creating Event Source...', key=SOURCE_READY),
progress_tracker.Stage('Subscribing Service...',
key=_TRIGGER_SUBSCRIBED),
progress_tracker.Stage('Linking Trigger...', key=_TRIGGER_DEPENDENCY),
]
def _ServiceStages():
"""Return a new mapping from conditions to Stages."""
return collections.OrderedDict([
('ConfigurationsReady',
progress_tracker.Stage('Creating Revision...')),
('RoutesReady', progress_tracker.Stage('Routing traffic...'))
])
def ServiceStages():
"""Return the progress tracker Stages for conditions of a Service."""
return [
progress_tracker.Stage('Creating Revision...',
key=SERVICE_CONFIGURATIONS_READY),
progress_tracker.Stage('Routing traffic...', key=SERVICE_ROUTES_READY)
]
def _GetProgressTracker(patch_job_name):
stages = [
progress_tracker.Stage(
'Generating instance details...', key='pre-summary'),
progress_tracker.Stage(
'Reporting instance details...', key='with-summary')
]
return progress_tracker.StagedProgressTracker(
message='Executing patch job [{0}]'.format(patch_job_name), stages=stages)
def ServiceStages(include_iam_policy_set=False):
"""Return the progress tracker Stages for conditions of a Service."""
stages = [
progress_tracker.Stage(
'Creating Revision...', key=SERVICE_CONFIGURATIONS_READY),
_NewRoutingTrafficStage()]
if include_iam_policy_set:
stages.append(progress_tracker.Stage(
'Setting IAM Policy...', key=SERVICE_IAM_POLICY_SET))
return stages
def _CreateProgressTracker(patch_job_name):
"""Creates a progress tracker to display patch status synchronously."""
stages = [
progress_tracker.Stage(
'Generating instance details...', key='pre-summary'),
progress_tracker.Stage(
'Reporting instance details...', key='with-summary')
]
return progress_tracker.StagedProgressTracker(
message='Executing patch job [{0}]'.format(patch_job_name), stages=stages)
def ApplyStages():
"""Returns the progress tracker Stages for apply command.
Returns:
array of progress_tracker.Stage
"""
return [
progress_tracker.Stage('Saving Configuration...', key=UPDATE_APPLICATION),
progress_tracker.Stage(
'Actuating Configuration...', key=CREATE_DEPLOYMENT),
]
def SetUp(self):
self._interactive_mock = self.StartObjectPatch(console_io, 'IsInteractive')
self._interactive_mock.return_value = True
self.console_size_mock = self.StartObjectPatch(
console_attr.ConsoleAttr, 'GetTermSize')
properties.VALUES.core.interactive_ux_style.Set(
properties.VALUES.core.InteractiveUXStyles.NORMAL.name)
self.stages = [
progress_tracker.Stage('Hello World...', key='a'),
progress_tracker.Stage('A' + 'h' * 15 + '...', key='b')]
self.keys = [s.key for s in self.stages]
def JobStages(include_completion=False):
"""Returns the list of progress tracker Stages for Jobs."""
stages = [
progress_tracker.Stage('Provisioning resources...',
key=_RESOURCES_AVAILABLE)
]
if include_completion:
stages.append(progress_tracker.Stage('Starting job...', key=_STARTED))
# Normally the last terminal condition (e.g. Ready or in this case
# Completed) wouldn't be included as a stage since it gates the entire
# progress tracker. But in this case we want to include it so we can show
# updates on this stage while the job is running.
stages.append(progress_tracker.Stage('Running job...', key=_COMPLETED))
return stages
def IntegrationDeleteStages():
"""Returns the progress tracker Stages for deleting an Integration.
Returns:
list of progress_tracker.Stage
"""
return [
progress_tracker.Stage('Unbinding services...', key=UPDATE_APPLICATION),
progress_tracker.Stage('Configuring services...', key=CREATE_DEPLOYMENT),
progress_tracker.Stage(
'Deleting Integration resources...', key=UNDEPLOY_RESOURCE),
progress_tracker.Stage(
'Saving Integration configurations...', key=CLEANUP_CONFIGURATION)
]
def ServiceStages(include_iam_policy_set=False,
include_route=True,
include_build=False):
"""Return the progress tracker Stages for conditions of a Service."""
stages = []
if include_build:
stages.append(_UploadSourceStage())
stages.append(_BuildContainerStage())
stages.append(
progress_tracker.Stage('Creating Revision...',
key=SERVICE_CONFIGURATIONS_READY))
if include_route:
stages.append(_NewRoutingTrafficStage())
if include_iam_policy_set:
stages.append(
progress_tracker.Stage('Setting IAM Policy...',
key=SERVICE_IAM_POLICY_SET))
return stages
def _RunStagedProgressTracker(self, args):
get_bread = progress_tracker.Stage('Getting bread...', key='bread')
get_pb_and_j = progress_tracker.Stage('Getting peanut butter...', key='pb')
make_sandwich = progress_tracker.Stage('Making sandwich...', key='make')
stages = [get_bread, get_pb_and_j, make_sandwich]
with progress_tracker.StagedProgressTracker(
'Making sandwich...',
stages,
success_message='Time to eat!',
failure_message='Time to order delivery..!',
tracker_id='meta.make_sandwich') as tracker:
tracker.StartStage('bread')
time.sleep(0.5)
tracker.UpdateStage('bread', 'Looking for bread in the pantry')
time.sleep(0.5)
tracker.CompleteStage('bread', 'Got some whole wheat bread!')
tracker.StartStage('pb')
time.sleep(1)
tracker.CompleteStage('pb')
tracker.StartStage('make')
time.sleep(1)
tracker.CompleteStage('make')
def IntegrationStages(create):
"""Returns the progress tracker Stages for creating or updating an Integration.
Args:
create: whether it's for the create command.
Returns:
list of progress_tracker.Stage
"""
return [
_UpdateApplicationStage(create),
progress_tracker.Stage(
'Configuring Integration...', key=CREATE_DEPLOYMENT),
]
def _UpdateApplicationStage(create):
"""Returns the stage for updating the Application.
Args:
create: whether it's for the create command.
Returns:
progress_tracker.Stage
"""
if create:
message = 'Saving Configuration for Integration...'
else:
message = 'Updating Configuration for Integration...'
return progress_tracker.Stage(message, key=UPDATE_APPLICATION)
def _WaitForLegacyNetworkMigration(self, operation_poller, operation_ref):
progress_stages = []
for key, label in self.MIGRATION_STAGES.items():
progress_stages.append(progress_tracker.Stage(label, key=key))
tracker = progress_tracker.StagedProgressTracker(
message='Migrating Network from Legacy to Custom Mode',
stages=progress_stages)
first_status_message = list(self.MIGRATION_STAGES.keys())[0]
tracker.last_status_message = first_status_message
return waiter.WaitFor(
poller=operation_poller,
operation_ref=operation_ref,
custom_tracker=tracker,
tracker_update_func=self._LegacyNetworkMigrationTrackerUpdateFunc)
def _GetStages(client, request, messages):
"""Returns None until stages have been loaded in the operation."""
operation = _GetOperation(client, request)
if operation.error:
raise exceptions.StatusToFunctionsError(operation.error)
if not operation.metadata:
return None
operation_metadata = _GetOperationMetadata(messages, operation)
if not operation_metadata.stages:
return None
stages = []
for stage in operation_metadata.stages:
message = '[{}]'.format(_GetStageName(stage.name))
stages.append(progress_tracker.Stage(message, key=str(stage.name)))
return stages
def Run(self, args):
"""Executes when the user runs the create command."""
conn_context = connection_context.EventsConnectionContext(args)
namespace_ref = args.CONCEPTS.namespace.Parse()
with eventflow_operations.Connect(conn_context) as client:
client.CreateBroker(namespace_ref.Name(), args.BROKER)
broker_full_name = 'namespaces/{}/brokers/{}'.format(
namespace_ref.Name(), args.BROKER)
with progress_tracker.StagedProgressTracker(
'Creating Broker...',
[progress_tracker.Stage('Creating Broker...')]) as tracker:
client.PollBroker(broker_full_name, tracker)
log.status.Print('Created broker [{}] in namespace [{}].'.format(
args.BROKER, namespace_ref.Name()))
def Run(self, args):
"""Executes when the user runs the create command."""
if platforms.GetPlatform() == platforms.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:
client.CreateBroker(namespace_ref.Name(), args.BROKER)
broker_full_name = 'namespaces/{}/brokers/{}'.format(
namespace_ref.Name(), args.BROKER)
with progress_tracker.StagedProgressTracker(
'Creating Broker...',
[progress_tracker.Stage('Creating Broker...')]) as tracker:
client.PollBroker(broker_full_name, tracker)
log.status.Print('Created broker [{}] in namespace [{}].'.format(
args.BROKER, namespace_ref.Name()))
def Run(self, args):
"""Runs local extraction then calls ODS with the results.
Args:
args: an argparse namespace. All the arguments that were provided to this
command invocation.
Returns:
AnalyzePackages operation.
"""
# Create the command wrapper immediately so we can fail fast if necessary.
cmd = Command()
# TODO(b/173619679): Validate RESOURCE_URI argument.
# Dynamically construct the stages based on the --async flag; when
# --async=true, we do not need a separate poll stage.
stages = [
progress_tracker.Stage(
EXTRACT_MESSAGE.format('remote' if args.remote else 'local'),
key='extract'),
progress_tracker.Stage(RPC_MESSAGE, key='rpc')
]
if not args.async_:
stages += [progress_tracker.Stage(POLL_MESSAGE, key='poll')]
messages = api_util.GetMessages()
with progress_tracker.StagedProgressTracker(SCAN_MESSAGE,
stages=stages) as tracker:
# Stage 1) Extract.
tracker.StartStage('extract')
operation_result = cmd(
resource_uri=args.RESOURCE_URI,
remote=args.remote,
fake_extraction=args.fake_extraction,
)
if operation_result.exit_code:
tracker.FailStage(
'extract', ExtractionFailedError(operation_result.stderr))
return
# Parse stdout for the JSON-ified PackageData protos.
pkgs = []
for pkg in json.loads(operation_result.stdout):
pkgs += [
messages.PackageData(
package=pkg['package'],
version=pkg['version'],
cpeUri=pkg['cpe_uri'],
)
]
tracker.CompleteStage('extract')
# Stage 2) Make the RPC to the On-Demand Scanning API.
tracker.StartStage('rpc')
op = api_util.AnalyzePackages(
properties.VALUES.core.project.Get(required=True),
args.location, args.RESOURCE_URI, pkgs)
tracker.CompleteStage('rpc')
# Stage 3) Poll the operation if requested.
response = None
if not args.async_:
tracker.StartStage('poll')
tracker.UpdateStage('poll', '[{}]'.format(op.name))
response = ods_util.WaitForOperation(op)
tracker.CompleteStage('poll')
if args.async_:
log.status.Print('Check operation [{}] for status.'.format(
op.name))
return op
return response
def DomainMappingStages():
return [progress_tracker.Stage('Creating Domain Mapping...', key=READY)]
def Run(self, args):
"""Runs local extraction then calls ODS with the results.
Args:
args: an argparse namespace. All the arguments that were provided to this
command invocation.
Returns:
AnalyzePackages operation.
Raises:
UnsupportedOS: when the command is run on a Windows machine.
"""
if platforms.OperatingSystem.IsWindows():
raise ods_util.UnsupportedOS(
'On-Demand Scanning is not supported on Windows')
# Verify that the local-extract component is installed, and prompt the user
# to install it if it's not.
try:
# If the user has access to the gcloud components manager, this will
# prompt the user to install it. If they do not have access, it will
# instead print the command to install it using a package manager.
update_manager.UpdateManager.EnsureInstalledAndRestart(
['local-extract'])
except update_manager.MissingRequiredComponentsError:
# Two possibilities with this error:
# 1. The user has access to the gcloud components manager but decided
# against intalling it.
# 2. The user does not have access to the gcloud components manager. A
# message was printed to the user with the command to install the
# component using their package manager (e.g. apt-get).
raise
except local_state.InvalidSDKRootError:
# This happens when gcloud is run locally, but not when distributed.
pass
# Construct the object which invokes the `local-extract` component. This
# might still fail if the binary is run locally.
cmd = Command()
# TODO(b/173619679): Validate RESOURCE_URI argument.
# Dynamically construct the stages based on the --async flag; when
# --async=true, we do not need a separate poll stage.
stages = [
progress_tracker.Stage(
EXTRACT_MESSAGE.format('remote' if args.remote else 'local'),
key='extract'),
progress_tracker.Stage(RPC_MESSAGE, key='rpc')
]
if not args.async_:
stages += [progress_tracker.Stage(POLL_MESSAGE, key='poll')]
messages = self.GetMessages()
with progress_tracker.StagedProgressTracker(SCAN_MESSAGE,
stages=stages) as tracker:
# Stage 1) Extract.
tracker.StartStage('extract')
operation_result = cmd(
resource_uri=args.RESOURCE_URI,
remote=args.remote,
fake_extraction=args.fake_extraction,
additional_package_types=args.additional_package_types,
experimental_package_types=args.experimental_package_types,
verbose_errors=args.verbose_errors,
)
if operation_result.exit_code:
# Filter out any log messages on std err and only include any actual
# extraction errors.
extraction_error = None
if operation_result.stderr:
extraction_error = '\n'.join([
line for line in operation_result.stderr.splitlines()
if line.startswith('Extraction failed')
])
if not extraction_error:
if operation_result.exit_code < 0:
extraction_error = EXTRACTION_KILLED_ERROR_TEMPLATE.format(
exit_code=operation_result.exit_code, )
else:
extraction_error = UNKNOWN_EXTRACTION_ERROR_TEMPLATE.format(
exit_code=operation_result.exit_code, )
tracker.FailStage(
'extract',
ods_util.ExtractionFailedError(extraction_error))
return
# Parse stdout for the JSON-ified PackageData protos.
pkgs = []
for pkg in json.loads(operation_result.stdout):
pkg_data = messages.PackageData(
package=pkg['package'],
version=pkg['version'],
cpeUri=pkg['cpe_uri'],
)
if 'package_type' in pkg:
pkg_data.packageType = arg_utils.ChoiceToEnum(
pkg['package_type'],
messages.PackageData.PackageTypeValueValuesEnum)
pkgs += [pkg_data]
tracker.CompleteStage('extract')
# Stage 2) Make the RPC to the On-Demand Scanning API.
tracker.StartStage('rpc')
op = self.AnalyzePackages(args, pkgs)
tracker.CompleteStage('rpc')
# Stage 3) Poll the operation if requested.
response = None
if not args.async_:
tracker.StartStage('poll')
tracker.UpdateStage('poll', '[{}]'.format(op.name))
response = self.WaitForOperation(op)
tracker.CompleteStage('poll')
if args.async_:
log.status.Print('Check operation [{}] for status.'.format(
op.name))
return op
return response
def _NewRoutingTrafficStage():
return progress_tracker.Stage('Routing traffic...',
key=SERVICE_ROUTES_READY)
('clear_secrets', '--clear-secrets'),
]
_UNSUPPORTED_V2_FLAG_ERROR = '`%s` is not yet supported in Cloud Functions V2.'
_CLOUD_RUN_SERVICE_COLLECTION_K8S = 'run.namespaces.services'
_CLOUD_RUN_SERVICE_COLLECTION_ONE_PLATFORM = 'run.projects.locations.services'
_DEFAULT_IGNORE_FILE = gcloudignore.DEFAULT_IGNORE_FILE + '\nnode_modules\n'
_ZIP_MIME_TYPE = 'application/zip'
_DEPLOYMENT_TOOL_LABEL = 'deployment-tool'
_DEPLOYMENT_TOOL_VALUE = 'cli-gcloud'
# cs/symbol:google.cloud.functions.v2main.Stage.Name.SERVICE_ROLLBACK
_SERVICE_ROLLBACK_STAGE = progress_tracker.Stage('[Healthcheck]',
key='SERVICE_ROLLBACK')
_TRIGGER_ROLLBACK_STAGE = progress_tracker.Stage('[Triggercheck]',
key='TRIGGER_ROLLBACK')
_EXTRA_STAGES = [_SERVICE_ROLLBACK_STAGE, _TRIGGER_ROLLBACK_STAGE]
# GCF 2nd generation control plane valid memory units
_GCF_GEN2_UNITS = [
'k',
'Ki',
'M',
'Mi',
'G',
'Gi',
'T',
'Ti',
from googlecloudsdk.core.console import progress_tracker
from googlecloudsdk.core.util import retry
DEFAULT_ENDPOINT_VERSION = 'v1'
_SERVERLESS_API_NAME = 'serverless'
_SERVERLESS_API_VERSION = 'v1alpha1'
# Wait 11 mins for each deployment. This is longer than the server timeout,
# making it more likely to get a useful error message from the server.
MAX_WAIT_MS = 660000
# Because gcloud cannot update multiple lines of output simultaneously, the
# order of conditions in this dictionary should match the order in which we
# expect Serverless resources to complete deployment.
_CONDITION_TO_STAGE = OrderedDict([
('ConfigurationsReady', progress_tracker.Stage(
'Creating Revision...')),
('RoutesReady', progress_tracker.Stage('Routing traffic...')),
('Ready', progress_tracker.Stage('Readying...'))])
class UnknownAPIError(exceptions.Error):
pass
@contextlib.contextmanager
def Connect(cluster_ref):
"""Provide a ServerlessOperations instance to use.
Arguments:
cluster_ref: Resource, the gke cluster to connect to if present. Otherwise,
connect to Hosted Serverless.
def _BuildFromSourceStage():
return progress_tracker.Stage(
'Building Container...', key=BUILD_READY)
def TriggerStages():
return [
progress_tracker.Stage('Subscribing Service...', key=_TRIGGER_SUBSCRIBED),
progress_tracker.Stage('Linking Trigger...', key=_TRIGGER_DEPENDENCY),
]
def TriggerAndSourceStages():
return [
progress_tracker.Stage('Creating Event Source...', key=SOURCE_READY)
] + TriggerStages()
def _UploadSourceStage():
return progress_tracker.Stage('Uploading sources...', key=UPLOAD_SOURCE)
def EventingStages():
return [
progress_tracker.Stage('Enabling Eventing...'),
]
def _CreateRepoStage():
return progress_tracker.Stage('Creating Container Repository...',
key=CREATE_REPO)
