def Run(self, args):
"""Run 'api-gateway gateways delete'.
Args:
args: argparse.Namespace, The arguments that this command was invoked
with.
Raises:
OperationCancelledError
Returns:
The response from the Delete API call.
"""
gateway_ref = args.CONCEPTS.gateway.Parse()
# Prompt with a warning before continuing.
console_io.PromptContinue(
message='Are you sure? This will delete the gateway \'{}\', '
'along with all of the associated consumer '
'information.'.format(gateway_ref.RelativeName()),
prompt_string='Continue anyway',
default=True,
throw_if_unattended=True,
cancel_on_no=True)
resp = gateways.GatewayClient().Delete(gateway_ref)
wait = 'Waiting for API Gateway [{}] to be deleted'.format(
gateway_ref.Name())
return operations_util.PrintOperationResult(
resp.name,
operations.OperationsClient(),
wait_string=wait,
is_async=args.async_)
def Run(self, args):
parent_ref = args.CONCEPTS.location.Parse()
return operations.OperationsClient().List(parent_ref.RelativeName(),
filters=args.filter,
limit=args.limit,
page_size=args.page_size)
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):
"""Run 'api-gateway api-configs delete'.
Args:
args: argparse.Namespace, The arguments that this command was invoked
with.
Returns:
The response from the Delete API call (or None if cancelled).
"""
api_config_ref = args.CONCEPTS.api_config.Parse()
# Prompt with a warning before continuing.
console_io.PromptContinue(
message='Are you sure? This will delete the API Config \'{}\', '
'along with all of the associated consumer '
'information.'.format(api_config_ref.RelativeName()),
prompt_string='Continue anyway',
default=True,
throw_if_unattended=True,
cancel_on_no=True)
client = api_configs.ApiConfigClient()
resp = client.Delete(api_config_ref)
wait = 'Waiting for API Config [{}] to be deleted'.format(
api_config_ref.Name())
return operations_util.PrintOperationResult(
resp.name,
operations.OperationsClient(),
wait_string=wait,
is_async=args.async_)
def Run(self, args):
gateway_ref = args.CONCEPTS.gateway.Parse()
api_config_ref = args.CONCEPTS.api_config.Parse()
gateways_client = gateways.GatewayClient()
resp = gateways_client.Create(gateway_ref,
api_config_ref,
display_name=args.display_name,
labels=args.labels)
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
op_client = operations.OperationsClient()
return op_client.WaitForOperation(
operation_ref,
'Waiting for API Gateway [{}] to be created with [{}] config'.
format(gateway_ref.Name(), api_config_ref.RelativeName()),
gateways_client.client.projects_locations_gateways)
def Run(self, args):
gateway_ref = args.CONCEPTS.gateway.Parse()
gateways_client = gateways.GatewayClient()
gateway, mask = self.ProcessUpdates(gateways_client.Get(gateway_ref),
args)
resp = gateways_client.Update(gateway, update_mask=mask)
op_client = operations.OperationsClient()
return op_client.GetOperationResult(resp, is_async=args.async_)
def Run(self, args):
gateway_ref = args.CONCEPTS.gateway.Parse()
api_config_ref = args.CONCEPTS.api_config.Parse()
gateways_client = gateways.GatewayClient()
resp = gateways_client.Create(gateway_ref,
api_config_ref,
display_name=args.display_name,
labels=args.labels)
op_client = operations.OperationsClient()
return op_client.GetOperationResult(resp, is_async=args.async_)
def Run(self, args):
api_ref = args.CONCEPTS.api.Parse()
api_client = apis.ApiClient()
api, mask = self.ProcessUpdates(api_client.Get(api_ref), args)
resp = api_client.Update(api, update_mask=mask)
return operations_util.PrintOperationResult(
resp.name,
operations.OperationsClient(),
service=api_client.service,
wait_string='Waiting for API [{}] to be updated'.format(api_ref.Name()),
is_async=args.async_)
def Run(self, args):
client = operations.OperationsClient()
operation_ref = args.CONCEPTS.operation.Parse()
console_io.PromptContinue(
message='The operation [{}] will be cancelled.'.format(
operation_ref.RelativeName()),
throw_if_unattended=True,
cancel_on_no=True)
client.Cancel(operation_ref)
operations_util.PrintOperationResultWithWaitEpilogue(
operation_ref, 'Operation cancellation requested')
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()
# Check to see if Api exists, create if not
if not apis.DoesExist(api_ref):
res = apis.Create(api_ref)
operations_util.PrintOperationResult(
res.name,
ops,
wait_string='Waiting for API [{}] to be created'.format(
api_ref.Name()))
open_api_docs = []
svc_configs = []
grpc_svc_defs = []
# When we add gRPC support back, we can remove the 'hasattr' call.
if hasattr(args, 'grpc_files') and args.grpc_files:
args.grpc_files = [f.strip() for f in args.grpc_files]
svc_configs, grpc_svc_defs = self.__GrpcMessages(args.grpc_files)
else:
args.openapi_spec = [f.strip() for f in args.openapi_spec]
open_api_docs = self.__OpenApiMessage(args.openapi_spec)
# Create ApiConfig object.
# Only piece affected by async right now
resp = api_configs.Create(
api_config_ref,
labels=args.labels,
display_name=args.display_name,
backend_auth=args.backend_auth_service_account,
managed_service_configs=svc_configs,
grpc_service_defs=grpc_svc_defs,
open_api_docs=open_api_docs)
wait = 'Waiting for API Config [{0}] to be created for API [{1}]'.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):
api_ref = args.CONCEPTS.api.Parse()
api_client = apis.ApiClient()
resp = api_client.Create(api_ref,
managed_service=args.managed_service,
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):
gateway_ref = args.CONCEPTS.gateway.Parse()
gateways_client = gateways.GatewayClient()
gateway, mask = self.ProcessUpdates(gateways_client.Get(gateway_ref), args)
resp = gateways_client.Update(gateway, update_mask=mask)
wait = 'Waiting for API Gateway [{}] to be updated'.format(
gateway_ref.Name())
return operations_util.PrintOperationResult(
resp.name,
operations.OperationsClient(),
service=gateways_client.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):
gateway_ref = args.CONCEPTS.gateway.Parse()
api_config_ref = args.CONCEPTS.api_config.Parse()
gateways_client = gateways.GatewayClient()
resp = gateways_client.Create(gateway_ref,
api_config_ref,
display_name=args.display_name,
labels=args.labels)
wait = 'Waiting for API Gateway [{}] to be created with [{}] config'.format(
gateway_ref.Name(), api_config_ref.RelativeName())
return operations_util.PrintOperationResult(
resp.name,
operations.OperationsClient(),
service=gateways_client.service,
wait_string=wait,
is_async=args.async_)
def Run(self, args):
client = operations.OperationsClient()
operation_ref = args.CONCEPTS.operation.Parse()
# To give a better message for already-completed operations, get the
# operation here and check if it's already completed.
operation = client.Get(operation_ref)
if operation.done:
msg_prefix = 'Operation has already completed.'
else:
# No need to check for the result, errors and timeouts are handled already
client.WaitForOperation(operation_ref)
msg_prefix = 'Operation completed successfully.'
log.status.Print('{} Use the following command for more details:\n\n'
'gcloud api-gateway operations describe {}\n'.format(
msg_prefix, operation_ref.RelativeName()))
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 'api-gateway gateways delete'.
Args:
args: argparse.Namespace, The arguments that this command was invoked
with.
Raises:
OperationCancelledError
Returns:
The response from the Delete API call.
"""
gateway_ref = args.CONCEPTS.gateway.Parse()
# Prompt with a warning before continuing.
console_io.PromptContinue(
message='Are you sure? This will delete the gateway \'{}\', '
'along with all of the associated consumer '
'information.'.format(gateway_ref.RelativeName()),
prompt_string='Continue anyway',
default=True,
throw_if_unattended=True,
cancel_on_no=True)
resp = gateways.GatewayClient().Delete(gateway_ref.RelativeName())
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
op_client = operations.OperationsClient()
return op_client.WaitForOperation(
operation_ref, 'Waiting for API Gateway [{}] to be deleted'.format(
gateway_ref.Name()))
def Run(self, args):
gateway_ref = args.CONCEPTS.gateway.Parse()
gateways_client = gateways.GatewayClient()
gateway, mask = self.ProcessUpdates(gateways_client.Get(gateway_ref),
args)
resp = gateways_client.Update(gateway, update_mask=mask)
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
op_client = operations.OperationsClient()
return op_client.WaitForOperation(
operation_ref, 'Waiting for API Gateway [{}] to be updated'.format(
gateway_ref.Name()),
gateways_client.client.projects_locations_gateways)
def Run(self, args):
client = operations.OperationsClient()
operation_ref = args.CONCEPTS.operation.Parse()
return client.Get(operation_ref)
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)
