def testParseBetaClearPushFlags(self):
flags.AddUpdatePushQueueFlags(self.parser,
release_track=base.ReleaseTrack.BETA)
expected_config = _BETA_MESSAGES_MODULE.Queue(
retryConfig=_BETA_MESSAGES_MODULE.RetryConfig(),
rateLimits=_BETA_MESSAGES_MODULE.RateLimits(),
stackdriverLoggingConfig=(
_BETA_MESSAGES_MODULE.StackdriverLoggingConfig()),
appEngineHttpQueue=_BETA_MESSAGES_MODULE.AppEngineHttpQueue(
appEngineRoutingOverride=_BETA_MESSAGES_MODULE.
AppEngineRouting()),
type=_BETA_MESSAGES_MODULE.Queue.TypeValueValuesEnum.PUSH)
args = self.parser.parse_args([
'--clear-log-sampling-ratio', '--clear-max-attempts',
'--clear-max-retry-duration', '--clear-max-doublings',
'--clear-min-backoff', '--clear-max-backoff',
'--clear-max-dispatches-per-second',
'--clear-max-concurrent-dispatches', '--clear-routing-override'
])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
_BETA_MESSAGES_MODULE,
is_update=True,
release_track=base.ReleaseTrack.BETA)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args, constants.PUSH_QUEUE,
self.is_alpha)
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
api.messages,
is_update=True,
is_alpha=self.is_alpha)
if not self.is_alpha:
app_engine_routing_override = (
queue_config.appEngineHttpQueue.appEngineRoutingOverride
if queue_config.appEngineHttpQueue is not None else None)
else:
app_engine_routing_override = (
queue_config.appEngineHttpTarget.appEngineRoutingOverride
if queue_config.appEngineHttpTarget is not None else None)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
update_response = queues_client.Patch(
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def testParseBetaCreateOrUpdateQueueArgs_AllArgs_MaxAttemptsUnlimited(
self):
expected_config = _BETA_MESSAGES_MODULE.Queue()
expected_config.retryConfig = _BETA_MESSAGES_MODULE.RetryConfig(
maxAttempts=-1,
maxRetryDuration='5s',
maxDoublings=4,
minBackoff='1s',
maxBackoff='10s')
expected_config.rateLimits = _BETA_MESSAGES_MODULE.RateLimits(
maxDispatchesPerSecond=100, maxConcurrentDispatches=10)
expected_config.stackdriverLoggingConfig = (
_BETA_MESSAGES_MODULE.StackdriverLoggingConfig(samplingRatio=0.5))
expected_config.appEngineHttpQueue = _BETA_MESSAGES_MODULE.AppEngineHttpQueue(
appEngineRoutingOverride={'service': 'abc'})
expected_config.type = _BETA_MESSAGES_MODULE.Queue.TypeValueValuesEnum.PUSH
args = self.parser.parse_args([
'--log-sampling-ratio=0.5', '--max-attempts=unlimited',
'--max-retry-duration=5s', '--max-doublings=4', '--min-backoff=1s',
'--max-backoff=10s', '--max-dispatches-per-second=100',
'--max-concurrent-dispatches=10', '--routing-override=service:abc'
])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
_BETA_MESSAGES_MODULE,
release_track=base.ReleaseTrack.BETA)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
api.messages,
release_track=self.ReleaseTrack())
if not self.is_alpha:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_queue=queue_config.appEngineHttpQueue,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig)
else:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_target=queue_config.appEngineHttpTarget)
log.CreatedResource(
parsers.GetConsolePromptString(queue_ref.RelativeName()), 'queue')
return create_response
def Run(self, args):
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
api.messages,
release_track=self.ReleaseTrack())
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
pull_target=queue_config.pullTarget)
else:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
queue_type=queue_config.type)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def Run(self, args):
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.queue)
configs = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PULL_QUEUE, queues_client.api.messages)
update_response = queues_client.Patch(queue_ref, *configs)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def Run(self, args):
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.id)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
configs = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PULL_QUEUE, queues_client.api.messages)
create_response = queues_client.Create(location_ref, queue_ref,
*configs)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def testParseCreateOrUpdateQueueArgs_NoArgs(self):
expected_config = _ALPHA_MESSAGES_MODULE.Queue()
expected_config.pullTarget = _ALPHA_MESSAGES_MODULE.PullTarget()
args = self.parser.parse_args([])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
_ALPHA_MESSAGES_MODULE,
release_track=base.ReleaseTrack.ALPHA)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
if self.ReleaseTrack() == base.ReleaseTrack.BETA:
queue_type = args.type
else:
queue_type = constants.PUSH_QUEUE
parsers.CheckUpdateArgsSpecified(args,
queue_type,
release_track=self.ReleaseTrack())
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
queue_type,
api.messages,
is_update=True,
release_track=self.ReleaseTrack())
updated_fields = parsers.GetSpecifiedFieldsMask(
args, queue_type, release_track=self.ReleaseTrack())
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
app_engine_routing_override = (
queue_config.appEngineHttpTarget.appEngineRoutingOverride
if queue_config.appEngineHttpTarget is not None else None)
update_response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override)
elif self.ReleaseTrack() == base.ReleaseTrack.BETA:
app_engine_routing_override = (
queue_config.appEngineHttpQueue.appEngineRoutingOverride
if queue_config.appEngineHttpQueue is not None else None)
update_response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig,
queue_type=queue_config.type)
else:
app_engine_routing_override = queue_config.appEngineRoutingOverride
update_response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args, constants.PULL_QUEUE)
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PULL_QUEUE, queues_client.api.messages, is_update=True)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
update_response = queues_client.Patch(
queue_ref, retry_config=queue_config.retryConfig)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def testParseBetaCreateOrUpdateQueueArgs_NoArgs(self):
expected_config = _BETA_MESSAGES_MODULE.Queue()
expected_config.appEngineHttpQueue = (
_BETA_MESSAGES_MODULE.AppEngineHttpQueue())
expected_config.type = _BETA_MESSAGES_MODULE.Queue.TypeValueValuesEnum.PUSH
args = self.parser.parse_args([])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
_BETA_MESSAGES_MODULE,
release_track=base.ReleaseTrack.BETA)
self.assertEqual(actual_config, expected_config)
def testParseCreateOrUpdateQueueArgs_AllArgs_MaxAttemptsUnlimited(self):
expected_config = _ALPHA_MESSAGES_MODULE.Queue()
expected_config.retryConfig = _ALPHA_MESSAGES_MODULE.RetryConfig(
unlimitedAttempts=True, maxRetryDuration='5s')
expected_config.pullTarget = _ALPHA_MESSAGES_MODULE.PullTarget()
args = self.parser.parse_args(
['--max-attempts=unlimited', '--max-retry-duration=5s'])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
_ALPHA_MESSAGES_MODULE,
release_track=base.ReleaseTrack.ALPHA)
self.assertEqual(actual_config, expected_config)
def testParseClearPullFlags(self):
flags.AddUpdatePullQueueFlags(self.parser)
expected_config = _ALPHA_MESSAGES_MODULE.Queue(
retryConfig=_ALPHA_MESSAGES_MODULE.RetryConfig())
args = self.parser.parse_args(
['--clear-max-attempts', '--clear-max-retry-duration'])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
_ALPHA_MESSAGES_MODULE,
is_update=True,
release_track=base.ReleaseTrack.ALPHA)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PULL_QUEUE, queues_client.api.messages)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
create_response = queues_client.Create(
location_ref, queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
pull_target=queue_config.pullTarget)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def testParseClearPushFlags(self):
flags.AddUpdatePushQueueFlags(self.parser)
expected_config = _MESSAGES_MODULE.Queue(
retryConfig=_MESSAGES_MODULE.RetryConfig(),
rateLimits=_MESSAGES_MODULE.RateLimits(),
appEngineRoutingOverride=_MESSAGES_MODULE.AppEngineRouting())
args = self.parser.parse_args([
'--clear-max-attempts', '--clear-max-retry-duration',
'--clear-max-doublings', '--clear-min-backoff',
'--clear-max-backoff', '--clear-max-dispatches-per-second',
'--clear-max-concurrent-dispatches', '--clear-routing-override'
])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PUSH_QUEUE, _MESSAGES_MODULE, is_update=True)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.id)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.APP_ENGINE_QUEUE, queues_client.api.messages)
log.warn(constants.QUEUE_MANAGEMENT_WARNING)
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_target=queue_config.appEngineHttpTarget)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def Run(self, args):
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.APP_ENGINE_QUEUE, api.messages, is_alpha=True)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_target=queue_config.appEngineHttpTarget)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args,
constants.PULL_QUEUE,
release_track=self.ReleaseTrack())
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
api.messages,
is_update=True,
release_track=base.ReleaseTrack.ALPHA)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
update_response = queues_client.Patch(
queue_ref, retry_config=queue_config.retryConfig)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args, constants.APP_ENGINE_QUEUE)
queues_client = queues.Queues()
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.APP_ENGINE_QUEUE, queues_client.api.messages,
is_update=True)
app_engine_routing_override = (
queue_config.appEngineHttpTarget.appEngineRoutingOverride if
queue_config.appEngineHttpTarget is not None else
None)
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
update_response = queues_client.Patch(
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override)
log.status.Print('Updated queue [{}].'.format(queue_ref.Name()))
return update_response
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args, constants.PULL_QUEUE,
release_track=self.ReleaseTrack())
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PULL_QUEUE,
api.messages,
is_update=True,
release_track=self.ReleaseTrack())
updated_fields = parsers.GetSpecifiedFieldsMask(
args, constants.PULL_QUEUE, release_track=self.ReleaseTrack())
update_response = queues_client.Patch(
queue_ref, updated_fields, retry_config=queue_config.retryConfig)
log.status.Print('Updated queue [{}].'.format(
parsers.GetConsolePromptString(queue_ref.RelativeName())))
return update_response
def testParseCreateOrUpdateQueueArgs_AllArgs_MaxAttemptsUnlimited(self):
expected_config = _MESSAGES_MODULE.Queue()
expected_config.retryConfig = _MESSAGES_MODULE.RetryConfig(
maxAttempts=-1,
maxRetryDuration='5s',
maxDoublings=4,
minBackoff='1s',
maxBackoff='10s')
expected_config.rateLimits = _MESSAGES_MODULE.RateLimits(
maxDispatchesPerSecond=100, maxConcurrentDispatches=10)
expected_config.appEngineRoutingOverride = {'service': 'abc'}
args = self.parser.parse_args([
'--max-attempts=unlimited', '--max-retry-duration=5s',
'--max-doublings=4', '--min-backoff=1s', '--max-backoff=10s',
'--max-dispatches-per-second=100',
'--max-concurrent-dispatches=10', '--routing-override=service:abc'
])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PUSH_QUEUE, _MESSAGES_MODULE)
self.assertEqual(actual_config, expected_config)
def Run(self, args):
if self.ReleaseTrack() == base.ReleaseTrack.BETA:
queue_type = args.type
else:
queue_type = constants.PUSH_QUEUE
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args, queue_type, api.messages, release_track=self.ReleaseTrack())
if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_target=queue_config.appEngineHttpTarget)
elif self.ReleaseTrack() == base.ReleaseTrack.BETA:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_queue=queue_config.appEngineHttpQueue,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig,
queue_type=queue_config.type)
else:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=queue_config.
appEngineRoutingOverride,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig)
log.CreatedResource(
parsers.GetConsolePromptString(queue_ref.RelativeName()), 'queue')
return create_response
def Run(self, args):
parsers.CheckUpdateArgsSpecified(args,
constants.PUSH_QUEUE,
release_track=self.ReleaseTrack())
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
api.messages,
is_update=True,
release_track=self.ReleaseTrack())
updated_fields = parsers.GetSpecifiedFieldsMask(
args, constants.PUSH_QUEUE, release_track=self.ReleaseTrack())
if not self.is_alpha:
app_engine_routing_override = (
queue_config.appEngineHttpQueue.appEngineRoutingOverride
if queue_config.appEngineHttpQueue is not None else None)
update_response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig)
else:
app_engine_routing_override = (
queue_config.appEngineHttpTarget.appEngineRoutingOverride
if queue_config.appEngineHttpTarget is not None else None)
update_response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override)
log.status.Print('Updated queue [{}].'.format(
parsers.GetConsolePromptString(queue_ref.RelativeName())))
return update_response
def Run(self, args):
api = GetApiAdapter(self.ReleaseTrack())
queues_client = api.queues
queue_ref = parsers.ParseQueue(args.queue, args.location)
location_ref = parsers.ExtractLocationRefFromQueueRef(queue_ref)
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
args,
constants.PUSH_QUEUE,
api.messages,
release_track=self.ReleaseTrack())
log.warning(constants.QUEUE_MANAGEMENT_WARNING)
if self.ReleaseTrack() == base.ReleaseTrack.ALPHA:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_target=queue_config.appEngineHttpTarget)
elif self.ReleaseTrack() == base.ReleaseTrack.BETA:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_http_queue=queue_config.appEngineHttpQueue,
stackdriver_logging_config=queue_config.
stackdriverLoggingConfig)
else:
create_response = queues_client.Create(
location_ref,
queue_ref,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=queue_config.
appEngineRoutingOverride)
log.CreatedResource(queue_ref.Name(), 'queue')
return create_response
def DeployQueuesYamlFile(
tasks_api,
config,
all_queues_in_db_dict,
ct_api_version=base.ReleaseTrack.BETA
):
"""Perform a deployment based on the parsed 'queue.yaml' file.
Args:
tasks_api: api_lib.tasks.<Alpha|Beta|GA>ApiAdapter, Cloud Tasks API needed
for doing queue based operations.
config: A yaml_parsing.ConfigYamlInfo object for the parsed YAML file we
are going to process.
all_queues_in_db_dict: A dictionary with queue names as keys and
corresponding apis.cloudtasks.<ver>.cloudtasks_<ver>_messages.Queue
objects as values
ct_api_version: The Cloud Tasks API version we want to use.
Returns:
A list of responses received from the Cloud Tasks APIs representing queue
states for every call made to modify the attributes of a queue.
"""
class _DummyQueueRef:
"""A dummy class to simulate queue_ref resource objects used in CT APIs.
This class simulates the behaviour of the resource object returned by
tasks.parsers.ParseQueue(...) function. We use this dummy class instead of
creating an actual resource instance because otherwise it takes roughly 2
minutes to create resource instances for a 1000 queues.
Attributes:
_relative_path: A string representing the full path for a queue in the
format: 'projects/<project>/locations/<location>/queues/<queue>'
"""
def __init__(self, relative_path):
"""Initializes the instance and sets the relative path."""
self._relative_path = relative_path
def RelativeName(self):
"""Gets the string representing the full path for a queue.
This is the only function we are currently using in CT APIs for the
queue_ref resource object.
Returns:
A string representing the full path for a queue in the following
format: 'projects/<project>/locations/<location>/queues/<queue>'
"""
return self._relative_path
queue_yaml = config.parsed
queues_client = tasks_api.queues
queues_not_present_in_yaml = set(all_queues_in_db_dict.keys())
# Just need to create one real instance of queue_ref. After that we can
# create dummy queue_ref objects based on this instance.
queue_ref = parsers.ParseQueue('a')
queue_ref_stub = queue_ref.RelativeName()[:-1]
# Get the arg values that we need to fill up for each queue using CT APIs
# pylint: disable=protected-access
task_args = flags._PushQueueFlags(release_track=ct_api_version)
# TODO(b/169069379) Remove max_burst_size when/if API is exposed via `gcloud
# tasks queues` CLI invocation.
task_args.append(base.Argument('--max_burst_size', type=int, help=''))
expected_args = []
for task_flag in task_args:
new_arg = task_flag.args[0][2:].replace('-', '_')
expected_args.extend((new_arg, 'clear_{}'.format(new_arg)))
responses = []
for queue in queue_yaml.queue:
if queue.name in queues_not_present_in_yaml:
queues_not_present_in_yaml.remove(queue.name)
queue_ref = _DummyQueueRef('{}{}'.format(queue_ref_stub, queue.name))
cur_queue_object = all_queues_in_db_dict.get(queue.name, None)
cloud_task_args = _PopulateCloudTasksArgs(queue, cur_queue_object,
expected_args)
rate_to_set = cloud_task_args.GetValue('max_dispatches_per_second')
if (
cur_queue_object and
(rate_to_set or queue.mode == constants.PULL_QUEUE) and
cur_queue_object.state in (cur_queue_object.state.DISABLED,
cur_queue_object.state.PAUSED)
):
# Resume queue if it exists, was previously disabled/paused and the
# new rate > 0
queues_client.Resume(queue_ref)
elif (
cur_queue_object and not rate_to_set and
cur_queue_object.state == cur_queue_object.state.RUNNING and
queue.mode == constants.PUSH_QUEUE
):
queues_client.Pause(queue_ref)
if not _AnyUpdatableFields(cloud_task_args):
# Queue attributes in DB == Queue attributes in YAML
continue
queue_config = parsers.ParseCreateOrUpdateQueueArgs(
cloud_task_args,
# Deliberately hardcoding push queues because we want to be able to
# modify all attributes even for pull queues.
constants.PUSH_QUEUE,
tasks_api.messages,
release_track=ct_api_version)
updated_fields = parsers.GetSpecifiedFieldsMask(
cloud_task_args, constants.PUSH_QUEUE, release_track=ct_api_version)
app_engine_routing_override = (
queue_config.appEngineHttpQueue.appEngineRoutingOverride
if queue_config.appEngineHttpQueue is not None else None)
response = queues_client.Patch(
queue_ref,
updated_fields,
retry_config=queue_config.retryConfig,
rate_limits=queue_config.rateLimits,
app_engine_routing_override=app_engine_routing_override,
queue_type=queue_config.type
)
responses.append(response)
if (
not cur_queue_object and
not rate_to_set and
queue.mode == constants.PUSH_QUEUE
):
# Pause queue if its a new push-queue and rate is zero.
queues_client.Pause(queue_ref)
for queue_name in queues_not_present_in_yaml:
queue = all_queues_in_db_dict[queue_name]
if queue.state in (queue.state.PAUSED, queue.state.DISABLED):
continue
queue_ref = _DummyQueueRef('{}{}'.format(queue_ref_stub, queue_name))
queues_client.Pause(queue_ref)
return responses
def testParseCreateOrUpdateQueueArgs_NoArgs(self):
expected_config = _MESSAGES_MODULE.Queue()
args = self.parser.parse_args([])
actual_config = parsers.ParseCreateOrUpdateQueueArgs(
args, constants.PUSH_QUEUE, _MESSAGES_MODULE)
self.assertEqual(actual_config, expected_config)
