core: file support

Author: mcuadros

core/docker.go

@@ -6,9 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
-	"os"
-	"path"
 	"sort"
 	"strconv"
 	"strings"
@@ -185,10 +182,9 @@ func (d *Docker) ListContainers(p *Project) ([]*Container, error) {
 }
 
 func (d *Docker) ListImages(p *Project) ([]*Image, error) {
-	Debug("Retrieving current containers", "project", p, "end-point", d.endPoint)
+	Debug("Retrieving current images", "project", p, "end-point", d.endPoint)
 
 	l, err := d.client.ListImages(docker.ListImagesOptions{All: true})
-
 	if err != nil {
 		return nil, err
 	}
@@ -216,7 +212,7 @@ func (d *Docker) BuildImage(
 	Debug("Building image", "project", p, "revision", rev, "end-point", d.endPoint)
 
 	input := bytes.NewBuffer(nil)
-	if err := d.buildTar(p, dockerfile.Get(), input); err != nil {
+	if err := d.buildTar(p, dockerfile, input); err != nil {
 		return err
 	}
 
@@ -395,52 +391,36 @@ func (d *Docker) formatPort(port string) (guest docker.Port, host docker.PortBin
 	return
 }
 
-func (d *Docker) buildTar(p *Project, dockerfile []byte, buf *bytes.Buffer) error {
-	t := time.Now()
-
+func (d *Docker) buildTar(p *Project, df *Dockerfile, buf *bytes.Buffer) error {
 	tr := tar.NewWriter(buf)
-	tr.WriteHeader(&tar.Header{
-		Name:       "Dockerfile",
-		Size:       int64(len(dockerfile)),
-		ModTime:    t,
-		AccessTime: t,
-		ChangeTime: t,
-	})
+	defer tr.Close()
 
-	if _, err := tr.Write(dockerfile); err != nil {
+	if err := d.addDockerFileToTar(tr, df); err != nil {
 		return err
 	}
 
-	for _, file := range p.Files {
-		if err := d.addFileToTar(file, tr); err != nil {
+	for _, f := range df.Files {
+		if err := d.addFileToTar(tr, f.Name, f.Content); err != nil {
 			return err
 		}
 	}
 
-	tr.Close()
 	return nil
 }
 
-func (d *Docker) addFileToTar(file string, tr *tar.Writer) error {
-	content, err := ioutil.ReadFile(file)
-	if err != nil {
-		return err
-	}
-
-	fInfo, err := os.Lstat(file)
-	if err != nil {
-		return err
-	}
-
-	h, err := tar.FileInfoHeader(fInfo, "")
-	h.Name = path.Base(file)
-	if err != nil {
-		return err
-	}
+func (d *Docker) addDockerFileToTar(tr *tar.Writer, df *Dockerfile) error {
+	return d.addFileToTar(tr, "Dockerfile", df.Get())
+}
 
-	if err := tr.WriteHeader(h); err != nil {
-		return err
-	}
+func (d *Docker) addFileToTar(tr *tar.Writer, file string, content []byte) error {
+	t := time.Now()
+	tr.WriteHeader(&tar.Header{
+		Name:       file,
+		Size:       int64(len(content)),
+		ModTime:    t,
+		AccessTime: t,
+		ChangeTime: t,
+	})
 
 	if _, err := tr.Write(content); err != nil {
 		return err

core/docker_group_test.go

@@ -18,7 +18,7 @@ func (s *CoreSuite) TestDockerGroup_BuildImage(c *C) {
 	p := &Project{Repository: "git@github.com:foo/bar.git", UseShortRevisions: true}
 	r := Revision{"foo/bar": Commit("qux")}
 	input := bytes.NewBuffer(nil)
-	result := dg.BuildImage(p, r, &Dockerfile{blob: []byte("")}, input)
+	result := dg.BuildImage(p, r, &Dockerfile{content: []byte("")}, input)
 
 	c.Assert(result, HasLen, 5)
 	for _, r := range result {
@@ -73,7 +73,7 @@ func (s *CoreSuite) TestDockerGroup_DeployListContainersAndListImages(c *C) {
 	r := Revision{"foo/bar": Commit("qux")}
 
 	input := bytes.NewBuffer(nil)
-	errors := dg.Deploy(p, r, &Dockerfile{blob: []byte("")}, input, true)
+	errors := dg.Deploy(p, r, &Dockerfile{content: []byte("")}, input, true)
 	c.Assert(errors, HasLen, 0)
 	c.Assert(string(input.Bytes()), HasLen, 255)
 

core/docker_test.go

@@ -9,7 +9,6 @@ import (
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
-	"path"
 	"time"
 
 	"github.com/fsouza/go-dockerclient"
@@ -33,7 +32,7 @@ func (s *CoreSuite) TestDocker_Deploy(c *C) {
 
 	d, _ := NewDocker(m.URL(), nil)
 	rev := Revision{"foo": "bar"}
-	err := d.Deploy(p, rev, &Dockerfile{blob: []byte("FROM base\n")}, input, false)
+	err := d.Deploy(p, rev, &Dockerfile{content: []byte("FROM base\n")}, input, false)
 	c.Assert(err, Equals, nil)
 
 	l, _ := d.ListContainers(p)
@@ -73,12 +72,10 @@ func (s *CoreSuite) TestDocker_BuildImage(c *C) {
 
 	defer ts.Close()
 
-	file := writeRandomFile("qux")
 	p := &Project{
 		Name:       "image",
 		Repository: "git@github.com:foo/bar.git",
 		NoCache:    true,
-		Files:      []string{file},
 	}
 
 	input := bytes.NewBuffer(nil)
@@ -87,13 +84,12 @@ func (s *CoreSuite) TestDocker_BuildImage(c *C) {
 	d, err := NewDocker(ts.URL, nil)
 	c.Assert(err, IsNil)
 
-	err = d.BuildImage(p, Revision{"key": "qux"}, &Dockerfile{blob: []byte("FROM base\n")}, input)
+	err = d.BuildImage(p, Revision{"key": "qux"}, &Dockerfile{content: []byte("FROM base\n")}, input)
 	c.Assert(err, IsNil)
 	s.Wait()
 
-	c.Assert(files, HasLen, 2)
+	c.Assert(files, HasLen, 1)
 	c.Assert(files["Dockerfile"], Equals, "FROM base\n")
-	c.Assert(files[path.Base(file)], Equals, "qux")
 	c.Assert(requests[0].URL.Query().Get("t"), Equals, "image:qux")
 	c.Assert(requests[0].URL.Query().Get("nocache"), Equals, "1")
 	c.Assert(requests[0].URL.Query().Get("rm"), Equals, "1")

core/dockerfile.go

@@ -7,23 +7,29 @@ import (
 )
 
 type Dockerfile struct {
-	blob        []byte
+	content     []byte
 	project     *Project
 	revision    Revision
 	environment *Environment
+	Files       []*File
 }
 
-func NewDockerfile(blob []byte, p *Project, r Revision, e *Environment) *Dockerfile {
+type File struct {
+	Name    string
+	Content []byte
+}
+
+func NewDockerfile(content []byte, p *Project, r Revision, e *Environment) *Dockerfile {
 	return &Dockerfile{
-		blob:        blob,
+		content:     content,
 		project:     p,
 		revision:    r,
 		environment: e,
 	}
 }
 
 func (d *Dockerfile) Get() []byte {
-	result := d.blob
+	result := d.content
 	result = d.resolveInfoVariables(result)
 	result = d.resolveEtcdVariables(result)
 

core/github.go

@@ -41,6 +41,27 @@ func (g *Github) GetDockerFile(p *Project) (content []byte, err error) {
 	return
 }
 
+func (g *Github) GetFiles(p *Project) (files []*File, err error) {
+	info := p.Repository.Info()
+	commit, err := g.doGetLastCommit(info)
+	if err != nil {
+		return
+	}
+
+	for _, f := range p.Files {
+		file := &File{Name: f}
+		file.Content, err = g.doGetFileContent(info, commit, f)
+
+		if err != nil {
+			return
+		}
+
+		files = append(files, file)
+	}
+
+	return
+}
+
 func (g *Github) GetLastCommit(p *Project) (Commit, error) {
 	return g.doGetLastCommit(p.Repository.Info())
 }

core/github_test.go

@@ -72,6 +72,24 @@ func (s *CoreSuite) TestGithub_GetDockerFile(c *C) {
 	c.Assert(string(content), Equals, "build\nhttp/bindata.go\n")
 }
 
+func (s *CoreSuite) TestGithub_GetFiles(c *C) {
+	if !*githubFlag {
+		c.Skip("-github not provided")
+	}
+
+	p := &Project{
+		Repository: "git@github.com:mcuadros/dockership.git",
+		Files:      []string{".gitignore"},
+	}
+
+	g := NewGithub(githubToken)
+	files, err := g.GetFiles(p)
+	c.Assert(err, Equals, nil)
+	c.Assert(files, HasLen, 1)
+	c.Assert(string(files[0].Name), Equals, ".gitignore")
+	c.Assert(string(files[0].Content), Equals, "build\nhttp/bindata.go\n")
+}
+
 func (s *CoreSuite) TestGithub_GetDockerFileNotFound(c *C) {
 	if !*githubFlag {
 		c.Skip("-github not provided")

core/project.go

@@ -67,6 +67,10 @@ func (p *Project) Deploy(environment string, output io.Writer, force bool) []err
 	}
 
 	file := NewDockerfile(blob, p, r, e)
+	file.Files, err = c.GetFiles(p)
+	if err != nil {
+		return []error{err}
+	}
 
 	errs = d.Deploy(p, r, file, output, force)
 	p.afterDeploy(prevStatus, e, errs)