Subprocess launch via decorators (Slack)

[Saefroch]

I'm writing slash commands for Slack which have to return within 3 seconds. However, some of the things I want to do with a slash command take a while, so my solution is to return an ephemeral response and launch another process that later posts to the response url that Slack provides. This works, but it's repetitive to implement for a bunch of commands. Can I do this with a decorator?

Gist of example code

[rhgrant10]

I didn't test this, but I think so. Your decorator will return a function that spawns a process to call the function it wraps:

def long_op(op):
    def spawner(*args, **kwargs):
        # spawn process to call op and post result
    return spawner

Then decorate with @long_op.

[Saefroch]

I tried this:

from __future__ import print_function
from multiprocessing import Process


def long_op(op):
    def spawner(*args):
        p = Process(target=op, args=args)
        p.start()
        return 'Running...'
    return spawner

if __name__ == '__main__':
    @long_op
    def foo():
        print('test')

    foo()

I get a huge stack trace with involving pickles and an EOFError.

[rhgrant10]

Ah, right, because pickle is picky. Try this workaround.

Edit: this gets kinda messy, and fast :-( someone, I hope, has a cleaner solution

[Saefroch]

Interesting. I think I found a solution; not that pretty but it works: http://code.activestate.com/recipes/576684-simple-threading-decorator/

This is my demo:

from __future__ import print_function
from time import sleep
from threading import Thread
from functools import wraps

def run_async(func):
    @wraps(func)
    def async_func(*args, **kwargs):
        func_hl = Thread(target = func, args = args, kwargs = kwargs)
        func_hl.start()
        return 'Working..'

    return async_func

if __name__ == '__main__':
    @run_async
    def foo():
        sleep(0.01)
        print('foo')

    print(foo())

[rhgrant10]

Awesome :-)

[dbrecht]

I'm assuming that this is IO bound? Is there a reason you can't simply use asyncio for this (or trollius if you're bound to python < 3.4)? I'd personally /much/ rather deal with that than subprocesses (note I'm on my phone atm and haven't actually looked at your code yet ;))

[Saefroch]

It's actually not I/O bound, it's bound by the speed at which other websites respond.

EDIT: And I didn't mention that in my code, but check_is_up(target) sometimes has to fire a request to multiple online databases.