github.com/tarrant/terraform@v0.3.8-0.20150402012457-f68c9eee638e/builtin/providers/docker/resource_docker_container_funcs.go (about)

     1  package docker
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"strconv"
     7  	"strings"
     8  
     9  	dc "github.com/fsouza/go-dockerclient"
    10  	"github.com/hashicorp/terraform/helper/schema"
    11  )
    12  
    13  func resourceDockerContainerCreate(d *schema.ResourceData, meta interface{}) error {
    14  	var err error
    15  	client := meta.(*dc.Client)
    16  
    17  	var data Data
    18  	if err := fetchLocalImages(&data, client); err != nil {
    19  		return err
    20  	}
    21  
    22  	image := d.Get("image").(string)
    23  	if _, ok := data.DockerImages[image]; !ok {
    24  		if _, ok := data.DockerImages[image+":latest"]; !ok {
    25  			return fmt.Errorf("Unable to find image %s", image)
    26  		} else {
    27  			image = image + ":latest"
    28  		}
    29  	}
    30  
    31  	// The awesome, wonderful, splendiferous, sensical
    32  	// Docker API now lets you specify a HostConfig in
    33  	// CreateContainerOptions, but in my testing it still only
    34  	// actually applies HostConfig options set in StartContainer.
    35  	// How cool is that?
    36  	createOpts := dc.CreateContainerOptions{
    37  		Name: d.Get("name").(string),
    38  		Config: &dc.Config{
    39  			Image:      image,
    40  			Hostname:   d.Get("hostname").(string),
    41  			Domainname: d.Get("domainname").(string),
    42  		},
    43  	}
    44  
    45  	if v, ok := d.GetOk("env"); ok {
    46  		createOpts.Config.Env = stringSetToStringSlice(v.(*schema.Set))
    47  	}
    48  
    49  	if v, ok := d.GetOk("command"); ok {
    50  		createOpts.Config.Cmd = stringListToStringSlice(v.([]interface{}))
    51  	}
    52  
    53  	exposedPorts := map[dc.Port]struct{}{}
    54  	portBindings := map[dc.Port][]dc.PortBinding{}
    55  
    56  	if v, ok := d.GetOk("ports"); ok {
    57  		exposedPorts, portBindings = portSetToDockerPorts(v.(*schema.Set))
    58  	}
    59  	if len(exposedPorts) != 0 {
    60  		createOpts.Config.ExposedPorts = exposedPorts
    61  	}
    62  
    63  	volumes := map[string]struct{}{}
    64  	binds := []string{}
    65  	volumesFrom := []string{}
    66  
    67  	if v, ok := d.GetOk("volumes"); ok {
    68  		volumes, binds, volumesFrom, err = volumeSetToDockerVolumes(v.(*schema.Set))
    69  		if err != nil {
    70  			return fmt.Errorf("Unable to parse volumes: %s", err)
    71  		}
    72  	}
    73  	if len(volumes) != 0 {
    74  		createOpts.Config.Volumes = volumes
    75  	}
    76  
    77  	var retContainer *dc.Container
    78  	if retContainer, err = client.CreateContainer(createOpts); err != nil {
    79  		return fmt.Errorf("Unable to create container: %s", err)
    80  	}
    81  	if retContainer == nil {
    82  		return fmt.Errorf("Returned container is nil")
    83  	}
    84  
    85  	d.SetId(retContainer.ID)
    86  
    87  	hostConfig := &dc.HostConfig{
    88  		PublishAllPorts: d.Get("publish_all_ports").(bool),
    89  	}
    90  
    91  	if len(portBindings) != 0 {
    92  		hostConfig.PortBindings = portBindings
    93  	}
    94  
    95  	if len(binds) != 0 {
    96  		hostConfig.Binds = binds
    97  	}
    98  	if len(volumesFrom) != 0 {
    99  		hostConfig.VolumesFrom = volumesFrom
   100  	}
   101  
   102  	if v, ok := d.GetOk("dns"); ok {
   103  		hostConfig.DNS = stringSetToStringSlice(v.(*schema.Set))
   104  	}
   105  
   106  	if err := client.StartContainer(retContainer.ID, hostConfig); err != nil {
   107  		return fmt.Errorf("Unable to start container: %s", err)
   108  	}
   109  
   110  	return resourceDockerContainerRead(d, meta)
   111  }
   112  
   113  func resourceDockerContainerRead(d *schema.ResourceData, meta interface{}) error {
   114  	client := meta.(*dc.Client)
   115  
   116  	apiContainer, err := fetchDockerContainer(d.Get("name").(string), client)
   117  	if err != nil {
   118  		return err
   119  	}
   120  
   121  	if apiContainer == nil {
   122  		// This container doesn't exist anymore
   123  		d.SetId("")
   124  
   125  		return nil
   126  	}
   127  
   128  	container, err := client.InspectContainer(apiContainer.ID)
   129  	if err != nil {
   130  		return fmt.Errorf("Error inspecting container %s: %s", apiContainer.ID, err)
   131  	}
   132  
   133  	if d.Get("must_run").(bool) && !container.State.Running {
   134  		return resourceDockerContainerDelete(d, meta)
   135  	}
   136  
   137  	return nil
   138  }
   139  
   140  func resourceDockerContainerUpdate(d *schema.ResourceData, meta interface{}) error {
   141  	return nil
   142  }
   143  
   144  func resourceDockerContainerDelete(d *schema.ResourceData, meta interface{}) error {
   145  	client := meta.(*dc.Client)
   146  
   147  	removeOpts := dc.RemoveContainerOptions{
   148  		ID:            d.Id(),
   149  		RemoveVolumes: true,
   150  		Force:         true,
   151  	}
   152  
   153  	if err := client.RemoveContainer(removeOpts); err != nil {
   154  		return fmt.Errorf("Error deleting container %s: %s", d.Id(), err)
   155  	}
   156  
   157  	d.SetId("")
   158  	return nil
   159  }
   160  
   161  func stringListToStringSlice(stringList []interface{}) []string {
   162  	ret := []string{}
   163  	for _, v := range stringList {
   164  		ret = append(ret, v.(string))
   165  	}
   166  	return ret
   167  }
   168  
   169  func stringSetToStringSlice(stringSet *schema.Set) []string {
   170  	ret := []string{}
   171  	if stringSet == nil {
   172  		return ret
   173  	}
   174  	for _, envVal := range stringSet.List() {
   175  		ret = append(ret, envVal.(string))
   176  	}
   177  	return ret
   178  }
   179  
   180  func fetchDockerContainer(name string, client *dc.Client) (*dc.APIContainers, error) {
   181  	apiContainers, err := client.ListContainers(dc.ListContainersOptions{All: true})
   182  
   183  	if err != nil {
   184  		return nil, fmt.Errorf("Error fetching container information from Docker: %s\n", err)
   185  	}
   186  
   187  	for _, apiContainer := range apiContainers {
   188  		// Sometimes the Docker API prefixes container names with /
   189  		// like it does in these commands. But if there's no
   190  		// set name, it just uses the ID without a /...ugh.
   191  		var dockerContainerName string
   192  		if len(apiContainer.Names) > 0 {
   193  			dockerContainerName = strings.TrimLeft(apiContainer.Names[0], "/")
   194  		} else {
   195  			dockerContainerName = apiContainer.ID
   196  		}
   197  
   198  		if dockerContainerName == name {
   199  			return &apiContainer, nil
   200  		}
   201  	}
   202  
   203  	return nil, nil
   204  }
   205  
   206  func portSetToDockerPorts(ports *schema.Set) (map[dc.Port]struct{}, map[dc.Port][]dc.PortBinding) {
   207  	retExposedPorts := map[dc.Port]struct{}{}
   208  	retPortBindings := map[dc.Port][]dc.PortBinding{}
   209  
   210  	for _, portInt := range ports.List() {
   211  		port := portInt.(map[string]interface{})
   212  		internal := port["internal"].(int)
   213  		protocol := port["protocol"].(string)
   214  
   215  		exposedPort := dc.Port(strconv.Itoa(internal) + "/" + protocol)
   216  		retExposedPorts[exposedPort] = struct{}{}
   217  
   218  		external, extOk := port["external"].(int)
   219  		ip, ipOk := port["ip"].(string)
   220  
   221  		if extOk {
   222  			portBinding := dc.PortBinding{
   223  				HostPort: strconv.Itoa(external),
   224  			}
   225  			if ipOk {
   226  				portBinding.HostIP = ip
   227  			}
   228  			retPortBindings[exposedPort] = append(retPortBindings[exposedPort], portBinding)
   229  		}
   230  	}
   231  
   232  	return retExposedPorts, retPortBindings
   233  }
   234  
   235  func volumeSetToDockerVolumes(volumes *schema.Set) (map[string]struct{}, []string, []string, error) {
   236  	retVolumeMap := map[string]struct{}{}
   237  	retHostConfigBinds := []string{}
   238  	retVolumeFromContainers := []string{}
   239  
   240  	for _, volumeInt := range volumes.List() {
   241  		volume := volumeInt.(map[string]interface{})
   242  		fromContainer := volume["from_container"].(string)
   243  		containerPath := volume["container_path"].(string)
   244  		hostPath := volume["host_path"].(string)
   245  		readOnly := volume["read_only"].(bool)
   246  
   247  		switch {
   248  		case len(fromContainer) == 0 && len(containerPath) == 0:
   249  			return retVolumeMap, retHostConfigBinds, retVolumeFromContainers, errors.New("Volume entry without container path or source container")
   250  		case len(fromContainer) != 0 && len(containerPath) != 0:
   251  			return retVolumeMap, retHostConfigBinds, retVolumeFromContainers, errors.New("Both a container and a path specified in a volume entry")
   252  		case len(fromContainer) != 0:
   253  			retVolumeFromContainers = append(retVolumeFromContainers, fromContainer)
   254  		case len(hostPath) != 0:
   255  			readWrite := "rw"
   256  			if readOnly {
   257  				readWrite = "ro"
   258  			}
   259  			retVolumeMap[containerPath] = struct{}{}
   260  			retHostConfigBinds = append(retHostConfigBinds, hostPath+":"+containerPath+":"+readWrite)
   261  		default:
   262  			retVolumeMap[containerPath] = struct{}{}
   263  		}
   264  	}
   265  
   266  	return retVolumeMap, retHostConfigBinds, retVolumeFromContainers, nil
   267  }