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 }