GitList

Browse code

Fix loading of containerized plugins

During daemon startup, all containers are registered before any are
started.
During container registration it was calling out to initialize volumes.
If the volume uses a plugin that is running in a container, this will
cause the restart of that container to fail since the plugin is not yet
running.
This also slowed down daemon startup since volume initialization was
happening sequentially, which can be slow (and is flat out slow since
initialization would fail but take 8 seconds for each volume to do it).

This fix holds off on volume initialization until after containers are
restarted and does the initialization in parallel.

The containers that are restarted will have thier volumes initialized
because they are being started. If any of these containers are using a
plugin they will just keep retrying to reach the plugin (up to the
timeout, which is 8seconds) until the container with the plugin is up
and running.

Signed-off-by: Brian Goff <cpuguy83@gmail.com>

Brian Goff authored on 2016/01/21 02:06:03
Showing 2 changed files

daemon/daemon.go

History View file @ 360d596

@@ -282,10 +282,6 @@ func (daemon *Daemon) Register(container *container.Container) error {
+                     		}
+                     	}
                     -	if err := daemon.prepareMountPoints(container); err != nil {
                     -		return err
                     -	}
+                    -
                      	return nil
+                     }
@@ -408,6 +404,23 @@ func (daemon *Daemon) restore() error {
+                     	}
                      	group.Wait()
                     +	// any containers that were started above would already have had this done,
                     +	// however we need to now prepare the mountpoints for the rest of the containers as well.
                     +	// This shouldn't cause any issue running on the containers that already had this run.
                     +	// This must be run after any containers with a restart policy so that containerized plugins
                     +	// can have a chance to be running before we try to initialize them.
                     +	for _, c := range containers {
                     +		group.Add(1)
                     +		go func(c *container.Container) {
                     +			defer group.Done()
                     +			if err := daemon.prepareMountPoints(c); err != nil {
                     +				logrus.Error(err)
                     +			}
                     +		}(c)
                     +	}
+                    +
                     +	group.Wait()
+                    +
                      	if !debug {
                      		if logrus.GetLevel() == logrus.InfoLevel {
                      			fmt.Println()

daemon/volumes.go

History View file @ 360d596

@@ -159,7 +159,6 @@ func (daemon *Daemon) registerMountPoints(container *container.Container, hostCo
                      func (daemon *Daemon) lazyInitializeVolume(containerID string, m *volume.MountPoint) error {
                      	if len(m.Driver) > 0 && m.Volume == nil {
                      		v, err := daemon.volumes.GetWithRef(m.Name, m.Driver, containerID)
+                    -
                      		if err != nil {
                      			return err
+                     		}