def Run(self, args):
apis = apis_client.ApiClient()
api_configs = api_configs_client.ApiConfigClient()
ops = operations_client.OperationsClient()
api_config_ref = args.CONCEPTS.api_config.Parse()
api_ref = api_config_ref.Parent()
service_name = common_flags.ProcessApiRefToEndpointsService(api_ref)
# Check if OP service exists with Api name, create if not, activate it
if not endpoints.DoesServiceExist(service_name):
endpoints.CreateService(service_name, api_ref.projectsId)
# Check to see if Api exists, create if not
if not apis.DoesExist(api_ref):
res = apis.Create(api_ref, service_name)
operations_util.PrintOperationResult(
res.name, ops,
wait_string='Waiting for API [{}] to be created'.format(
api_ref.Name()))
# Create OP ServiceConfig and Rollout
# Creating a suffix to avoid name collisions on ServiceConfig IDs.
suffix = '-' + str(int(time.time()))
length = MAX_SERVICE_CONFIG_ID_LENGTH - len(suffix)
config_id = api_config_ref.Name()[:length] + suffix
if args.openapi_spec:
service_config_id = self.__PushOpenApiServiceFile(
args.openapi_spec,
service_name,
api_config_ref.projectsId,
config_id=config_id)
else:
service_config_id = self.__PushGrpcConfigFiles(
args.grpc_files,
service_name,
api_config_ref.projectsId,
config_id=config_id)
rollout = endpoints.CreateRollout(service_config_id, service_name)
# Create ApiConfig object using the service config and rollout
# Only piece affected by async right now
resp = api_configs.Create(api_config_ref,
rollout['rolloutId'],
labels=args.labels,
display_name=args.display_name,
backend_auth=args.backend_auth_service_account)
wait = 'Waiting for API Config [{}] to be created for API [{}]'.format(
api_config_ref.Name(), api_ref.Name())
return operations_util.PrintOperationResult(
resp.name,
ops,
service=api_configs.service,
wait_string=wait,
is_async=args.async_)
def Run(self, args):
apis = apis_client.ApiClient()
api_configs = api_configs_client.ApiConfigClient()
ops = operations_client.OperationsClient()
api_config_ref = args.CONCEPTS.api_config.Parse()
api_ref = api_config_ref.Parent()
service_name = '{}.apigateway.{}.cloud.goog'.format(
api_ref.Name(), api_ref.projectsId)
# Check if OP service exists with Api name, create if not, activate it
if not endpoints.DoesServiceExist(service_name):
endpoints.CreateService(service_name, api_ref.projectsId)
# Check to see if Api exists, create if not
if not apis.DoesExist(api_ref):
res = apis.Create(api_ref, service_name)
ops.GetOperationResult(res)
# Create OP ServiceConfig and Rollout
if args.openapi_spec:
service_config_id = self.__PushOpenApiServiceFile(
args.openapi_spec,
service_name,
api_config_ref.projectsId,
config_id=api_config_ref.Name())
else:
service_config_id = self.__PushGrpcConfigFiles(
args.grpc_files,
service_name,
api_config_ref.projectsId,
config_id=api_config_ref.Name())
rollout = endpoints.CreateRollout(service_config_id, service_name)
# Create ApiConfig object using the service config and rollout
# Only piece affected by async right now
resp = api_configs.Create(
api_config_ref,
rollout['rolloutId'],
labels=args.labels,
display_name=args.display_name,
backend_auth=args.backend_auth_service_account)
return ops.GetOperationResult(resp, is_async=args.async_)
def Run(self, args):
api_ref = args.CONCEPTS.api.Parse()
service_name = common_flags.ProcessApiRefToEndpointsService(api_ref)
api_client = apis.ApiClient()
# Check if OP service exists with Api name, create if not, activate it
if not endpoints.DoesServiceExist(service_name):
endpoints.CreateService(service_name, api_ref.projectsId)
resp = api_client.Create(api_ref,
service_name,
labels=args.labels,
display_name=args.display_name)
return operations_util.PrintOperationResult(
resp.name,
ops.OperationsClient(),
service=api_client.service,
wait_string='Waiting for API [{}] to be created'.format(api_ref.Name()),
is_async=args.async_)
def Run(self, args):
"""Run 'endpoints services deploy'.
Args:
args: argparse.Namespace, The arguments that this command was invoked
with.
Returns:
The response from the Update API call.
Raises:
BadFileExceptionn: if the provided service configuration files are
invalid or cannot be read.
"""
messages = services_util.GetMessagesModule()
client = services_util.GetClientInstance()
file_types = messages.ConfigFile.FileTypeValueValuesEnum
self.service_name = self.service_version = config_contents = None
config_files = []
self.validate_only = args.validate_only
# TODO(b/77867100): remove .proto support and deprecation warning.
give_proto_deprecate_warning = False
# If we're not doing a validate-only run, we don't want to output the
# resource directly unless the user specifically requests it using the
# --format flag. The Epilog will show useful information after deployment
# is complete.
if not self.validate_only and not args.IsSpecified('format'):
args.format = 'none'
for service_config_file in args.service_config_file:
config_contents = services_util.ReadServiceConfigFile(
service_config_file)
if services_util.FilenameMatchesExtension(
service_config_file, ['.json', '.yaml', '.yml']):
# Try to load the file as JSON. If that fails, try YAML.
service_config_dict = services_util.LoadJsonOrYaml(
config_contents)
if not service_config_dict:
raise calliope_exceptions.BadFileException(
'Could not read JSON or YAML from service config file '
'[{0}].'.format(service_config_file))
if 'swagger' in service_config_dict:
if 'host' not in service_config_dict:
raise calliope_exceptions.BadFileException((
'Malformed input. Found Swagger service config in file [{}], '
'but no host was specified. Add a host specification to the '
'config file.').format(service_config_file))
if not self.service_name and service_config_dict.get(
'host'):
self.service_name = service_config_dict.get('host')
# Always use YAML for Open API because JSON is a subset of YAML.
config_files.append(
self.MakeConfigFileMessage(config_contents,
service_config_file,
file_types.OPEN_API_YAML))
elif service_config_dict.get('type') == 'google.api.Service':
if not self.service_name and service_config_dict.get(
'name'):
self.service_name = service_config_dict.get('name')
config_files.append(
self.MakeConfigFileMessage(
config_contents, service_config_file,
file_types.SERVICE_CONFIG_YAML))
elif 'name' in service_config_dict:
# This is a special case. If we have been provided a Google Service
# Configuration file which has a service 'name' field, but no 'type'
# field, we have to assume that this is a normalized service config,
# and can be uploaded via the CreateServiceConfig API. Therefore,
# we can short circute the process here.
if len(args.service_config_file) > 1:
raise calliope_exceptions.BadFileException((
'Ambiguous input. Found normalized service configuration in '
'file [{0}], but received multiple input files. To upload '
'normalized service config, please provide it separately from '
'other input files to avoid ambiguity.'
).format(service_config_file))
# If this is a validate-only run, abort now, since this is not
# supported in the ServiceConfigs.Create API
if self.validate_only:
raise exceptions.InvalidFlagError(
'The --validate-only flag is not supported when using '
'normalized service configs as input.')
self.service_name = service_config_dict.get('name')
config_files = []
break
else:
raise calliope_exceptions.BadFileException((
'Unable to parse Open API, or Google Service Configuration '
'specification from {0}').format(service_config_file))
elif services_util.IsProtoDescriptor(service_config_file):
config_files.append(
self.MakeConfigFileMessage(
config_contents, service_config_file,
file_types.FILE_DESCRIPTOR_SET_PROTO))
elif services_util.IsRawProto(service_config_file):
give_proto_deprecate_warning = True
config_files.append(
self.MakeConfigFileMessage(config_contents,
service_config_file,
file_types.PROTO_FILE))
else:
raise calliope_exceptions.BadFileException((
'Could not determine the content type of file [{0}]. Supported '
'extensions are .json .yaml .yml .pb and .descriptor'
).format(service_config_file))
if give_proto_deprecate_warning:
log.warning(
'Support for uploading uncompiled .proto files is deprecated and '
'will soon be removed. Use compiled descriptor sets (.pb) instead.'
)
# Check to see if the Endpoints meta service needs to be enabled.
enable_api.EnableServiceIfDisabled(
properties.VALUES.core.project.Get(required=True),
services_util.GetEndpointsServiceName(), args. async)
# Check if we need to create the service.
if not services_util.DoesServiceExist(self.service_name):
project_id = properties.VALUES.core.project.Get(required=True)
# Deploying, even with validate-only, cannot succeed without the service
# being created
if self.validate_only:
if not console_io.CanPrompt():
log.error(
VALIDATE_NEW_ERROR.format(
service_name=self.service_name,
project_id=project_id))
return None
if not console_io.PromptContinue(
VALIDATE_NEW_PROMPT.format(
service_name=self.service_name,
project_id=project_id)):
return None
services_util.CreateService(self.service_name, project_id)
if config_files:
push_config_result = services_util.PushMultipleServiceConfigFiles(
self.service_name,
config_files,
args. async,
validate_only=self.validate_only)
self.service_config_id = (
services_util.GetServiceConfigIdFromSubmitConfigSourceResponse(
push_config_result))
else:
push_config_result = services_util.PushNormalizedGoogleServiceConfig(
self.service_name,
properties.VALUES.core.project.Get(required=True),
services_util.LoadJsonOrYaml(config_contents))
self.service_config_id = push_config_result.id
if not self.service_config_id:
raise exceptions.InvalidConditionError(
'Failed to retrieve Service Configuration Id.')
# Run the Push Advisor to see if we need to warn the user of any
# potentially hazardous changes to the service configuration.
if self.CheckPushAdvisor(args.force):
return None
# Create a Rollout for the new service configuration
if not self.validate_only:
percentages = messages.TrafficPercentStrategy.PercentagesValue()
percentages.additionalProperties.append(
(messages.TrafficPercentStrategy.PercentagesValue.
AdditionalProperty(key=self.service_config_id, value=100.0)))
traffic_percent_strategy = messages.TrafficPercentStrategy(
percentages=percentages)
rollout = messages.Rollout(
serviceName=self.service_name,
trafficPercentStrategy=traffic_percent_strategy,
)
rollout_create = messages.ServicemanagementServicesRolloutsCreateRequest(
rollout=rollout,
serviceName=self.service_name,
)
rollout_operation = client.services_rollouts.Create(rollout_create)
services_util.ProcessOperationResult(rollout_operation,
args. async)
# Check to see if the service is already enabled
enable_api.EnableServiceIfDisabled(
properties.VALUES.core.project.Get(required=True),
self.service_name, args. async)
return push_config_result
def Run(self, args):
apis = apis_client.ApiClient()
api_configs = api_configs_client.ApiConfigClient()
ops = operations_client.OperationsClient()
api_config_ref = args.CONCEPTS.api_config.Parse()
api_ref = api_config_ref.Parent()
service_name = '{}.apigateway.{}.cloud.goog'.format(
api_ref.Name(), api_ref.projectsId)
# Check if OP service exists with Api name, create if not, activate it
if not endpoints.DoesServiceExist(service_name):
endpoints.CreateService(service_name, api_ref.projectsId)
# Check to see if Api exists, create if not
if not apis.DoesExist(api_ref):
res = apis.Create(api_ref, service_name)
operation_ref = resources.REGISTRY.Parse(
res.name,
collection='apigateway.projects.locations.operations')
ops.WaitForOperation(
operation_ref,
'Waiting for API [{}] to be created'.format(api_ref.Name()))
# Create OP ServiceConfig and Rollout
if args.openapi_spec:
service_config_id = self.__PushOpenApiServiceFile(
args.openapi_spec,
service_name,
api_config_ref.projectsId,
config_id=api_config_ref.Name())
else:
service_config_id = self.__PushGrpcConfigFiles(
args.grpc_files,
service_name,
api_config_ref.projectsId,
config_id=api_config_ref.Name())
rollout = endpoints.CreateRollout(service_config_id, service_name)
# Create ApiConfig object using the service config and rollout
# Only piece affected by async right now
resp = api_configs.Create(
api_config_ref,
rollout['rolloutId'],
labels=args.labels,
display_name=args.display_name,
backend_auth=args.backend_auth_service_account)
operation_ref = resources.REGISTRY.Parse(
resp.name, collection='apigateway.projects.locations.operations')
# If async operation, simply log and return the result on passed in object
if args.async_:
operations_util.PrintOperationResultWithWaitEpilogue(
operation_ref, 'Asynchronous operation is in progress')
return resp
return ops.WaitForOperation(
operation_ref,
'Waiting for API Config [{}] to be created for API [{}]'.format(
api_config_ref.Name(), api_ref.Name()),
api_configs.client.projects_locations_apis_configs)