It is possible to async a local_action in ansible? - ansible

Question

I'm using Ansible to provision vagrant machines. Now I want the playbook to uncompress the database dump, import it in the vm and then recompress it back.
In "normal" mode this is not a big deal, but since my dumps can be pretty big the uncompress/compress operation take lots of time. I would like to use the "fire and forget" method described here https://docs.ansible.com/playbooks_async.html
The idea is:
"fire and forget" the dump bunzip
[ do all the other operations like package install, configurations ecc]
get back to the bunzip
import dump
fire and forget dump recompression
If I attempt to bunzip using a local_action it dies with ERROR: unexpected error: unable to determine jid
It is possible to do an async local task?
Edit
Tasks list example
# start async unzip
- name: bunzip dump
command: bunzip2 /vagrant/vagrant_provision/dump.sql.bz2
async: 10000
poll: 0
register: bunzip_status
#[... do other things ...]
# connect back to unzip and wait for it to end
- name: Check for dump bunzip
async_status: jid={{ bunzip_status.ansible_job_id }}
register: bunzip_result
until: bunzip_result.finished
retries: 80
#[... Import db ...]
# Fire and forget dump recompression
- name: Recompress dump
command: bzip2 /vagrant/vagrant_provision/dump.sql
async: 10000
poll: 0
Now.. since I'm using this to provision a vagrant environment I partially solved by putting my playbook and files inside the vagrant shared folder and referencing them by absolute path, and it works.
But the question is: It is possible to async a local_action (or even simply a delegate_to)?
In this case the use of local_action instead to do the archive/unarchive remotely allows me to use all my cpus (4 versus 1 assigned to vm) to do those operations and that I can even shutdown the vm during the final recompression without having to wait for it to finish.

Answer 1

I've gotten to the point where I make use of gnu screen whenever I want to background/async a command in Ansible so that I can verify that the command is running properly.
Given what you're describing you'd need to come up with a way to notify Ansible when you've reached step #3. To do that you'd probably want to create a temporary flag file that Ansible can look for. So to do what you describe I'd probably do something along these lines:
First, I'd create a wrapper script to unbzip the file just to make things a bit cleaner. It would create the flag file that I mentioned when the bunzip is complete. Here's a bare-bones example:
#!/bin/bash
rm -f /tmp/bunzip.done
bunzip /path/to/file.bz2
touch /tmp/bunzip.done
exit
Then I'd then execute this from within Ansible in a screen session like this (I use sudo in this example since I also typically sudo my screen sessions to a specific user):
- name: invoke bunzip script
local_action: command /usr/bin/screen -d -m sudo -u someuser /path/to/bzip_script.sh
async: True
poll: 0
At this point you can do whatever you need to do within Ansible. Once you get to step #3 then you would want to do something like this:
- name: wait for bunzip if it is still running
local_action: wait_for path=/tmp/bunzip.done state=present
As long as the wait_for script returns without error you should be able to safely reference the bunzipped data at this point. wait_for defaults to a 300 second timeout, so you may need to increase that if you expect bunzip to take longer.