def Run(self, args): flags.ValidateDiskSize('--disk-size', args.disk_size) env_ref = args.CONCEPTS.environment.Parse() env_name = env_ref.Name() if not command_util.IsValidEnvironmentName(env_name): raise command_util.InvalidUserInputError( 'Invalid environment name: [{}]. Must match pattern: {}'. format(env_name, command_util.ENVIRONMENT_NAME_PATTERN.pattern)) zone_ref = parsers.ParseZone(args.zone) if args.zone else None zone = zone_ref.RelativeName() if zone_ref else None machine_type = None network = None subnetwork = None if args.machine_type: machine_type = parsers.ParseMachineType( args.machine_type, fallback_zone=zone_ref.Name() if zone_ref else None).RelativeName() if args.network: network = parsers.ParseNetwork(args.network).RelativeName() if args.subnetwork: subnetwork = parsers.ParseSubnetwork( args.subnetwork, fallback_region=env_ref.Parent().Name()).RelativeName() operation = environments_api_util.Create( env_ref, args.node_count, labels=args.labels, location=zone, machine_type=machine_type, network=network, subnetwork=subnetwork, env_variables=args.env_variables, airflow_config_overrides=args.airflow_configs, service_account=args.service_account, oauth_scopes=args.oauth_scopes, tags=args.tags, disk_size_gb=args.disk_size >> 30, release_track=self.ReleaseTrack()) details = 'with operation [{0}]'.format(operation.name) if args. async: log.CreatedResource(env_ref.RelativeName(), kind='environment', is_async=True, details=details) return operation else: try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be created with [{}]'.format( env_ref.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.OperationError as e: raise command_util.EnvironmentCreateError( 'Error creating [{}]: {}'.format(env_ref.RelativeName(), str(e)))
def Run(self, args): self.ParseIpAliasConfigOptions(args) self.ParsePrivateEnvironmentConfigOptions(args) if self._support_web_server_cloud_sql_private_ip_ranges: self.ParsePrivateEnvironmentWebServerCloudSqlRanges(args) flags.ValidateDiskSize('--disk-size', args.disk_size) self.env_ref = args.CONCEPTS.environment.Parse() env_name = self.env_ref.Name() if not command_util.IsValidEnvironmentName(env_name): raise command_util.InvalidUserInputError( 'Invalid environment name: [{}]. Must match pattern: {}'. format(env_name, command_util.ENVIRONMENT_NAME_PATTERN.pattern)) self.zone_ref = parsers.ParseZone(args.zone) if args.zone else None self.zone = self.zone_ref.RelativeName() if self.zone_ref else None self.machine_type = None self.network = None self.subnetwork = None if args.machine_type: self.machine_type = parsers.ParseMachineType( args.machine_type, fallback_zone=self.zone_ref.Name() if self.zone_ref else None).RelativeName() if args.network: self.network = parsers.ParseNetwork(args.network).RelativeName() if args.subnetwork: self.subnetwork = parsers.ParseSubnetwork( args.subnetwork, fallback_region=self.env_ref.Parent().Name()).RelativeName() self.image_version = None if args.airflow_version: self.image_version = image_versions_util.ImageVersionFromAirflowVersion( args.airflow_version) elif args.image_version: self.image_version = args.image_version operation = self.GetOperationMessage(args) details = 'with operation [{0}]'.format(operation.name) if args.async_: log.CreatedResource(self.env_ref.RelativeName(), kind='environment', is_async=True, details=details) return operation else: try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be created with [{}]'.format( self.env_ref.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.OperationError as e: raise command_util.EnvironmentCreateError( 'Error creating [{}]: {}'.format( self.env_ref.RelativeName(), six.text_type(e)))
def Run(self, args): operation_ref = args.CONCEPTS.operation.Parse() operation = operations_api_util.Get(operation_ref, release_track=self.ReleaseTrack()) operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to complete.'.format(operation.name), release_track=self.ReleaseTrack())
def _SynchronousExecution(self, env_resource, operation): try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be updated with [{}]'.format( env_resource.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.Error as e: raise command_util.Error( 'Error restarting web server [{}]: {}'.format( env_resource.RelativeName(), six.text_type(e)))
def _SynchronousExecution(self, env_resource, operation): try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be updated with [{}]'.format( env_resource.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.Error as e: raise command_util.Error( 'Failed to load the snapshot of the environment [{}]: {}'. format(env_resource.RelativeName(), six.text_type(e)))
def Patch(env_resource, field_mask, patch, is_async, release_track=base.ReleaseTrack.GA): """Patches an Environment, optionally waiting for the operation to complete. This function is intended to perform the common work of an Environment patching command's Run method. That is, calling the patch API method and waiting for the result or immediately returning the Operation. Args: env_resource: googlecloudsdk.core.resources.Resource, Resource representing the Environment to be patched field_mask: str, a field mask string containing comma-separated paths to be patched patch: Environment, a patch Environment containing updated values to apply is_async: bool, whether or not to perform the patch asynchronously release_track: base.ReleaseTrack, the release track of command. Will dictate which Composer client library will be used. Returns: an Operation corresponding to the Patch call if `is_async` is True; otherwise None is returned after the operation is complete Raises: command_util.Error: if `is_async` is False and the operation encounters an error """ operation = environments_api_util.Patch(env_resource, patch, field_mask, release_track=release_track) details = 'with operation [{0}]'.format(operation.name) if is_async: log.UpdatedResource(env_resource.RelativeName(), kind='environment', is_async=True, details=details) return operation try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be updated with [{}]'.format( env_resource.RelativeName(), operation.name), release_track=release_track) except command_util.Error as e: raise command_util.Error('Error updating [{}]: {}'.format( env_resource.RelativeName(), six.text_type(e)))
def Wait(self): """Polls pending deletions and returns when they are complete.""" encountered_errors = False for pending_delete in self.pending_deletes: try: operations_api_util.WaitForOperation( pending_delete.operation, 'Waiting for [{}] to be deleted'.format( pending_delete.environment_name)) except command_util.OperationError as e: encountered_errors = True log.DeletedResource( pending_delete.environment_name, kind='environment', is_async=False, failed=six.text_type(e)) return encountered_errors
def Run(self, args): flags.ValidateDiskSize('--disk-size', args.disk_size) self.env_ref = args.CONCEPTS.environment.Parse() env_name = self.env_ref.Name() if not command_util.IsValidEnvironmentName(env_name): raise command_util.InvalidUserInputError( 'Invalid environment name: [{}]. Must match pattern: {}'. format(env_name, command_util.ENVIRONMENT_NAME_PATTERN.pattern)) self.zone_ref = parsers.ParseZone(args.zone) if args.zone else None self.zone = self.zone_ref.RelativeName() if self.zone_ref else None self.machine_type = None self.network = None self.subnetwork = None if args.machine_type: self.machine_type = parsers.ParseMachineType( args.machine_type, fallback_zone=self.zone_ref.Name() if self.zone_ref else None).RelativeName() if args.network: self.network = parsers.ParseNetwork(args.network).RelativeName() if args.subnetwork: self.subnetwork = parsers.ParseSubnetwork( args.subnetwork, fallback_region=self.env_ref.Parent().Name()).RelativeName() operation = self.GetOperationMessage(args) details = 'with operation [{0}]'.format(operation.name) if args. async: log.CreatedResource(self.env_ref.RelativeName(), kind='environment', is_async=True, details=details) return operation else: try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be created with [{}]'.format( self.env_ref.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.OperationError as e: raise command_util.EnvironmentCreateError( 'Error creating [{}]: {}'.format( self.env_ref.RelativeName(), str(e)))
def Run(self, args): operation_ref = args.CONCEPTS.operation.Parse() operation = operations_api_util.Get(operation_ref) operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to complete.'.format(operation.name))