func LoadImage(client *docker.Client, r io.Reader) (err error) {
opts := docker.LoadImageOptions{
InputStream: r,
}
if err = client.LoadImage(opts); err != nil {
return
}
return
}
func (p *DockerInDockerPool) clientInit(client *dockerapi.Client) error {
if len(p.preloadImages) == 0 {
return client.Ping()
}
for _, imageData := range p.preloadImages {
err := client.LoadImage(dockerapi.LoadImageOptions{
InputStream: bytes.NewReader(imageData),
})
if err != nil {
return err
}
}
return nil
}
// loadImage creates an image by loading it from the file system
func (d *DockerDriver) loadImage(driverConfig *DockerDriverConfig, client *docker.Client, taskDir string) error {
var errors multierror.Error
for _, image := range driverConfig.LoadImages {
archive := filepath.Join(taskDir, allocdir.TaskLocal, image)
d.logger.Printf("[DEBUG] driver.docker: loading image from: %v", archive)
f, err := os.Open(archive)
if err != nil {
errors.Errors = append(errors.Errors, fmt.Errorf("unable to open image archive: %v", err))
continue
}
if err := client.LoadImage(docker.LoadImageOptions{InputStream: f}); err != nil {
errors.Errors = append(errors.Errors, err)
}
f.Close()
}
return errors.ErrorOrNil()
}
func syncImages(client *dockerclient.Client, imageRoot string) error {
logrus.Debugf("Syncing images from %s", imageRoot)
f, err := os.Open(filepath.Join(imageRoot, "images.json"))
if err != nil {
return fmt.Errorf("error opening image json file: %v", err)
}
defer f.Close()
var m tagMap
if err := json.NewDecoder(f).Decode(&m); err != nil {
return fmt.Errorf("error decoding images json: %v", err)
}
allTags := map[string]struct{}{}
neededImages := map[string]struct{}{}
for imageID, tags := range m {
neededImages[imageID] = struct{}{}
for _, t := range tags {
allTags[t] = struct{}{}
}
}
images, err := client.ListImages(dockerclient.ListImagesOptions{})
if err != nil {
return fmt.Errorf("error listing images: %v", err)
}
for _, img := range images {
expectedTags, ok := m[img.ID]
if ok {
delete(neededImages, img.ID)
repoTags := filterRepoTags(img.RepoTags)
logrus.Debugf("Tags for %s: %#v", img.ID, repoTags)
// Sync tags for image ID
removedTags, addedTags := listDiff(repoTags, expectedTags)
for _, t := range addedTags {
if err := tagImage(client, img.ID, t); err != nil {
return err
}
}
for _, t := range removedTags {
// Check if this image tag conflicts with an expected
// tag, in which case force tag will update
if _, ok := allTags[t]; !ok {
logrus.Debugf("Removing tag %s", t)
if err := client.RemoveImage(t); err != nil {
return fmt.Errorf("error removing tag %s: %v", t, err)
}
}
}
} else {
removeOptions := dockerclient.RemoveImageOptions{
Force: true,
}
if err := client.RemoveImageExtended(img.ID, removeOptions); err != nil {
return fmt.Errorf("error moving image %s: %v", img.ID, err)
}
}
}
for imageID := range neededImages {
tags, ok := m[imageID]
if !ok {
return fmt.Errorf("missing image %s in tag map", imageID)
}
_, err := client.InspectImage(imageID)
if err != nil {
tf, err := os.Open(filepath.Join(imageRoot, imageID+".tar"))
if err != nil {
return fmt.Errorf("error opening image tar %s: %v", imageID, err)
}
defer tf.Close()
loadOptions := dockerclient.LoadImageOptions{
InputStream: tf,
}
if err := client.LoadImage(loadOptions); err != nil {
return fmt.Errorf("error loading image %s: %v", imageID, err)
}
}
for _, t := range tags {
if err := tagImage(client, imageID, t); err != nil {
return err
}
}
}
return nil
}