如何在某些事件上从容器向主机发送信号？

Question

I have a mariadb running in a container. On 'docker run', an import script (from a db dump) is run by mariadb, which creates users, builds schema, etc.

As the size of that dump script grows, the time to do the import increases. At this point it's about 8-10 seconds, but i expect amount of data to increase substantially, and the import time will be more difficult to predict.

I'd like to be able to send a signal from the container to the host, to let it know that the data has been loaded, and that db is ready to be used. So far i have found info on how to send signal from one container to another container, but there's no information on how to send signal from container to the host. Also, i need to be able to do this programmatically, as creating container is part part of a larger pipeline.

Ideally, i'd like to be able to do something like this:

client = docker.from_env()
db_c = client.containers.run('my_db_image', ....)

# check for signal from db_c container
# do other things

Thank you!

Answer 1

you can add this code to check if the db is ready to accept the connections:

import MySQLdb
import time


db = MySQLdb.connect(host='MYHost', user='MYNAME', passwd='PASS', db='MYDB')

if not db:
    while True:
        db = MySQLdb.connect(host='MYHost', user='MYNAME', passwd='PASS', db='MYDB')
        if db:
            break
        print("Still waiting for the DB")
        time.sleep(10)

Answer 2

AFAIK you cannot send signals from the container to a process running on the host but there are other ways to know when the import has finished. I think the easiest is to start the container in detached mode and wait until a specific line gets logged . The following script for example waits until the line done is logged:

import os
import docker

client = docker.from_env()

container = client.containers.run('ubuntu:latest', 'bash -c "for i in {1..10}; do sleep 1; echo working; done; echo done"', detach=True)
print('container started')

for line in container.logs(stream=True):
    print line.strip()
    if line.strip() == 'done':
        break

print('continue....')

If the output of the import script goes to stdout it could contain a simple print at the end:

select 'The import has finished' AS '';

Wait for this string in the python script.

Another approach is to use some other form of inter-process communication . An example using named pipes:

import os
import docker
import errno

client = docker.from_env()

FIFO = '/tmp/apipe'

# create the pipe
try:
    os.mkfifo(FIFO)
except OSError as oe: 
    if oe.errno != errno.EEXIST:
        raise
# start the container sharing the pipe
container = client.containers.run('ubuntu:latest', 'bash -c "sleep 5; echo done > /tmp/apipe"', volumes={FIFO: {'bind': FIFO, 'mode': 'rw'}}, detach=True)
print("container started")

with open(FIFO) as fifo:
    print("FIFO opened")
    while True:
        data = fifo.read()
        if len(data) == 0:
            print("Writer closed")
            break
        print('Read: "{0}"'.format(data))

print("continue...")

The host shares the named pipe with the container. In the python script the read call to the FIFO is blocked until some data is available in the pipe. In the container the import script writes to the pipe notifying the program that the data has been loaded. The mysql system command, \! command to execute an external command might come in handy in this situation. You could simply add to the end of the script:

\! echo done > /tmp/apipe

In a similar way you could use IPC sockets (aka Unix sockets) or shared memory but things get a bit more complicated.

Yet another solution is to add a health-check to the container. The health status can be polled on the host by inspecting the container. See How to wait until docker start is finished?

Edited: The above approaches assume the container is initialized and accepting connections. If the script is executed as part of the initialization process ( Initializing a fresh instance ), which seems to be the case here, the database is not ready and accepting connections when the import completes. For the initialization the server is temporarily started with the --skip_networking (allowing only local clients) and only after the initialization completes it is restarted and becomes available remotely.