diff --git a/platypush/backend/http/__init__.py b/platypush/backend/http/__init__.py index b2fd7939a7..9706c06356 100644 --- a/platypush/backend/http/__init__.py +++ b/platypush/backend/http/__init__.py @@ -239,7 +239,7 @@ class HttpBackend(Backend): if isinstance(msg, Request): try: - response = msg.execute(async=False) + response = msg.execute(_async=False) except PermissionError: abort(401) diff --git a/platypush/config/__init__.py b/platypush/config/__init__.py index 96e48ad906..9ba88369ab 100644 --- a/platypush/config/__init__.py +++ b/platypush/config/__init__.py @@ -148,10 +148,10 @@ class Config(object): self.cronjobs[cron_name] = self._config[key] elif key.startswith('procedure.'): tokens = key.split('.') - async = True if tokens[1] == 'async' else False + _async = True if tokens[1] == 'async' else False procedure_name = '.'.join(tokens[2:]) self.procedures[procedure_name] = { - 'async': async, + '_async': _async, 'actions': self._config[key] } else: diff --git a/platypush/cron/scheduler.py b/platypush/cron/scheduler.py index 8b597a7ecf..2bf46d9643 100644 --- a/platypush/cron/scheduler.py +++ b/platypush/cron/scheduler.py @@ -27,7 +27,7 @@ class Cronjob(Thread): context = {} for action in self.actions: - response = action.execute(async=False, **context) + response = action.execute(_async=False, **context) logger.info('Response from cronjob {}: {}'.format(self.name, response)) diff --git a/platypush/message/request/__init__.py b/platypush/message/request/__init__.py index 3ef9f3277c..713f59943d 100644 --- a/platypush/message/request/__init__.py +++ b/platypush/message/request/__init__.py @@ -71,7 +71,7 @@ class Request(Message): proc_name = self.action.split('.')[-1] proc_config = Config.get_procedures()[proc_name] proc = Procedure.build(name=proc_name, requests=proc_config['actions'], - async=proc_config['async'], + _async=proc_config['_async'], backend=self.backend, id=self.id) return proc.execute(*args, **kwargs) @@ -159,12 +159,12 @@ class Request(Message): 'origin attached: {}'.format(response)) - def execute(self, n_tries=1, async=True, **context): + def execute(self, n_tries=1, _async=True, **context): """ Execute this request and returns a Response object Params: n_tries -- Number of tries in case of failure before raising a RuntimeError - async -- If True, the request will be run asynchronously and the + _async -- If True, the request will be run asynchronously and the response posted on the bus when available (default), otherwise the current thread will wait for the response to be returned synchronously. @@ -212,7 +212,7 @@ class Request(Message): if self.token is None or get_hash(self.token) != token_hash: raise PermissionError() - if async: + if _async: Thread(target=_thread_func, args=(n_tries,)).start() else: return _thread_func(n_tries) diff --git a/platypush/procedure/__init__.py b/platypush/procedure/__init__.py index ba898cff95..a7abe06c00 100644 --- a/platypush/procedure/__init__.py +++ b/platypush/procedure/__init__.py @@ -11,17 +11,17 @@ logger = logging.getLogger(__name__) class Procedure(object): """ Procedure class. A procedure is a pre-configured list of requests """ - def __init__(self, name, async, requests, backend=None): + def __init__(self, name, _async, requests, backend=None): """ Params: name -- Procedure name - async -- Whether the actions in the procedure are supposed to + _async -- Whether the actions in the procedure are supposed to be executed sequentially or in parallel (True or False) requests -- List of platylist.message.request.Request objects """ self.name = name - self.async = async + self._async = _async self.requests = requests self.backend = backend @@ -30,7 +30,7 @@ class Procedure(object): @classmethod - def build(cls, name, async, requests, backend=None, id=None, **kwargs): + def build(cls, name, _async, requests, backend=None, id=None, **kwargs): reqs = [] loop_count = 0 if_count = 0 @@ -47,11 +47,11 @@ class Procedure(object): # A 'for' loop is synchronous. Declare a 'fork' loop if you # want to process the elements in the iterable in parallel - async = True if m.group(1) == 'fork' else False + _async = True if m.group(1) == 'fork' else False iterator_name = m.group(2) iterable = m.group(3) - loop = LoopProcedure.build(name=loop_name, async=async, + loop = LoopProcedure.build(name=loop_name, _async=_async, requests=request_config[key], backend=backend, id=id, iterator_name=iterator_name, @@ -87,7 +87,7 @@ class Procedure(object): request = Request.build(request_config) reqs.append(request) - return cls(name=name, async=async, requests=reqs, backend=backend, **kwargs) + return cls(name=name, _async=_async, requests=reqs, backend=backend, **kwargs) def execute(self, n_tries=1, **context): @@ -105,10 +105,10 @@ class Procedure(object): if token: request.token = token - context['async'] = self.async; context['n_tries'] = n_tries + context['_async'] = self._async; context['n_tries'] = n_tries response = request.execute(**context) - if not self.async: + if not self._async: if isinstance(response.output, dict): for (k,v) in response.output.items(): context[k] = v @@ -145,15 +145,15 @@ class LoopProcedure(Procedure): context = {} - def __init__(self, name, iterator_name, iterable, requests, async=False, backend=None, **kwargs): - super(). __init__(name=name, async=async, requests=requests, backend=None, **kwargs) + def __init__(self, name, iterator_name, iterable, requests, _async=False, backend=None, **kwargs): + super(). __init__(name=name, _async=_async, requests=requests, backend=None, **kwargs) self.iterator_name = iterator_name self.iterable = iterable self.requests = requests - def execute(self, async=None, **context): + def execute(self, _async=None, **context): iterable = Request.expand_value_from_context(self.iterable, **context) response = Response() @@ -192,7 +192,7 @@ class IfProcedure(Procedure): context = {} def __init__(self, name, condition, requests, else_branch=[], backend=None, id=None, **kwargs): - kwargs['async'] = False + kwargs['_async'] = False self.condition = condition self.else_branch = [] reqs = []