// b2d hosts need to wait for the daemon to be up
// before continuing with provisioning
if err = WaitForDocker(provisioner, engine.DefaultPort); err != nil {
    return err
}

if err = makeDockerOptionsDir(provisioner); err != nil {
    return err
}

provisioner.AuthOptions = setRemoteAuthOptions(provisioner)

if err = ConfigureAuth(provisioner); err != nil {
    return err
}

func checkDaemonUp(p Provisioner, dockerPort int) func() bool {
	reDaemonListening := fmt.Sprintf(":%d\\s+.*:.*", dockerPort)
	return func() bool {
		// HACK: Check netstat's output to see if anyone's listening on the Docker API port.
		netstatOut, err := p.SSHCommand("if ! type netstat 1>/dev/null; then ss -tln; else netstat -tln; fi")
		if err != nil {
			log.Warnf("Error running SSH command: %s", err)
			return false
		}

		return matchNetstatOut(reDaemonListening, netstatOut)
	}
}

matchNetstatOut = regexp.MatchString(reDaemonListening, line)

func (provisioner *Boot2DockerProvisioner) Service(name string, action serviceaction.ServiceAction) error {
    _, err := provisioner.SSHCommand(fmt.Sprintf("sudo /etc/init.d/%s %s", name, action.String()))
    return err
}

bits := 2048 


p.Service("docker", serviceaction.Stop);
.
log.Info("Copying certs to the local machine directory...");.
.
.
dockerPort := engine.DefaultPort
parts := strings.Split(u.Host, ":")
if len(parts) == 2 {
    dPort, err := strconv.Atoi(parts[1])
    if err != nil {
        return err
    }
    dockerPort = dPort
}
.
.
.

p.Service("docker", serviceaction.Start);
.
return WaitForDocker(p, dockerPort);

func (provisioner *Boot2DockerProvisioner) SSHCommand(args string) (string, error) {
	return drivers.RunSSHCommandFromDriver(provisioner.Driver, args)
}

func GetSSHClientFromDriver(d Driver) (ssh.Client, error) {
	address, err := d.GetSSHHostname()
	if err != nil {
		return nil, err
	}

	port, err := d.GetSSHPort()
	if err != nil {
		return nil, err
	}

	var auth *ssh.Auth
	if d.GetSSHKeyPath() == "" {
		auth = &ssh.Auth{}
	} else {
		auth = &ssh.Auth{
			Keys: []string{d.GetSSHKeyPath()},
		}
	}

	client, err := ssh.NewClient(d.GetSSHUsername(), address, port, auth)
	return client, err

}

func RunSSHCommandFromDriver(d Driver, command string) (string, error) {
	client, err := GetSSHClientFromDriver(d)
	if err != nil {
		return "", err
	}

	log.Debugf("About to run SSH command:\n%s", command)

	output, err := client.Output(command)
	log.Debugf("SSH cmd err, output: %v: %s", err, output)
	if err != nil {
		return "", fmt.Errorf(`ssh command error:
command : %s
err     : %v
output  : %s`, command, err, output)
	}

	return output, nil
}

func WaitForSpecificOrError(f func() (bool, error), maxAttempts int, waitInterval time.Duration) error {
	for i := 0; i < maxAttempts; i++ {
		stop, err := f()
		if err != nil {
			return err
		}
		if stop {
			return nil
		}
		time.Sleep(waitInterval)
	}
	return fmt.Errorf("Maximum number of retries (%d) exceeded", maxAttempts)
}

func WaitForSpecific(f func() bool, maxAttempts int, waitInterval time.Duration) error {
	return WaitForSpecificOrError(func() (bool, error) {
		return f(), nil
	}, maxAttempts, waitInterval)
}

// Driver defines how a host is created and controlled. Different types of
// driver represent different ways hosts can be created (e.g. different
// hypervisors, different cloud providers)
type Driver interface {
    // Create a host using the driver's config
    Create() error

    // DriverName returns the name of the driver
    DriverName() string

    // GetCreateFlags returns the mcnflag.Flag slice representing the flags
    // that can be set, their descriptions and defaults.
    GetCreateFlags() []mcnflag.Flag

    // GetIP returns an IP or hostname that this host is available at
    // e.g. 1.2.3.4 or docker-host-d60b70a14d3a.cloudapp.net
    GetIP() (string, error)

    // GetMachineName returns the name of the machine
    GetMachineName() string

    // GetSSHHostname returns hostname for use with ssh
    GetSSHHostname() (string, error)

    // GetSSHKeyPath returns key path for use with ssh
    GetSSHKeyPath() string

    // GetSSHPort returns port for use with ssh
    GetSSHPort() (int, error)

    // GetSSHUsername returns username for use with ssh
    GetSSHUsername() string

    // GetURL returns a Docker compatible host URL for connecting to this host
    // e.g. tcp://1.2.3.4:2376
    GetURL() (string, error)

    // GetState returns the state that the host is in (running, stopped, etc)
    GetState() (state.State, error)

    // Kill stops a host forcefully
    Kill() error

    // PreCreateCheck allows for pre-create operations to make sure a driver is ready for creation
    PreCreateCheck() error

    // Remove a host
    Remove() error

    // Restart a host. This may just call Stop(); Start() if the provider does not
    // have any special restart behaviour.
    Restart() error

    // SetConfigFromFlags configures the driver with the object that was returned
    // by RegisterCreateFlags
    SetConfigFromFlags(opts DriverOptions) error

    // Start a host
    Start() error

    // Stop a host gracefully
    Stop() error
}

u.Host from GetUrl() from Implementation of Driver
That's ALL of it.

// b2d hosts need to wait for the daemon to be up
// before continuing with provisioning

provisioners          = make(map[string]*RegisteredProvisioner)  <===hashmap