files

docker/Dockerfile.build

@@ -2,21 +2,23 @@
 
 FROM golang:1.8.1
 
-ADD . /buildme
-WORKDIR buildme
+ADD src/buildme $GOPATH/src/buildme
 
-ENV GOPATH=/buildme
+RUN go get github.com/docker/docker # Prefetch
 
+ENV GOPATH=$GOPATH:/buildme
+
+WORKDIR $GOPATH
 # DEPS
 RUN go get -v buildme/cmd/builder
 # CODE TEST
 # RUN go test something
 # BUILD
-RUN CGO_ENABLED=0 go build -o DIST/builder buildme/cmd/builder
+RUN CGO_ENABLED=0 go build -o /DIST/builder buildme/cmd/builder
 # ENV TEST
 
 # DIST
-RUN tar -cz DIST >dist.tar.gz
+RUN tar -cz /DIST >dist.tar.gz
 
 # Generate img
-CMD cat dist.tar.gz
+#CMD cat dist.tar.gz

docker/Dockerfile.build3

@@ -4,7 +4,9 @@ RUN apk add --update git
 
 ADD . /buildme
 WORKDIR /buildme
+# Optimize goget
+RUN go get github.com/docker/docker
 
 RUN make deps
-
-CMD make dist
+RUN make dist
+RUN ls .

src/buildme/buildme.go

@@ -67,7 +67,7 @@ func Fetch(ftype string, fpath string) (*Project, error) {
 
 // Build Fetch url/path and run docker build
 ///////////////////////////////////////////////////////////////// BUILD
-func Build(ftype string, fpath string) error {
+func Build(ftype string, fpath string, projName string) error {
 	var err error
 
 	// Fetch proj from tar
@@ -77,8 +77,11 @@ func Build(ftype string, fpath string) error {
 	}
 	defer proj.Close()
 	Prepare(proj)
+	if projName != "" {
+		proj.SetName(projName)
+	}
 
-	proj.Docker()
+	DockerBuild(proj)
 	//addDockerfile(proj)
 
 	//////////////////////

src/buildme/docker.go

@@ -0,0 +1,81 @@
+package buildme
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	docker "github.com/docker/docker/client"
+)
+
+func DockerBuild(p *Project) error {
+	log.Println("New docker environ")
+	cli, err := docker.NewEnvClient()
+	if err != nil {
+		return err
+	}
+
+	dockertag := fmt.Sprintf("%s-builder", p.Name)
+	log.Println("Building and tagging:", dockertag)
+	///////////////
+	/// DOCKER OPERATION / BUILDER operation
+	ctx := context.Background()
+	{
+		log.Println("Docker image build dockerfile:", p.Dockerfile)
+		imageRes, err := cli.ImageBuild(ctx, p.Reader(), types.ImageBuildOptions{Tags: []string{dockertag}, Dockerfile: p.Dockerfile})
+		if err != nil {
+			return err
+		}
+		defer imageRes.Body.Close()
+		io.Copy(os.Stdout, imageRes.Body) // Do some treatment somehow
+		//inf, err := cli.Info(ctx)
+		//log.Println("Info:", inf, err)
+	}
+
+	{
+
+		log.Println("Testing running the builder")
+		containerName := dockertag
+		containerCfg := &container.Config{AttachStdout: true, Cmd: []string{"cat", "/buildme/dist.tar.gz"}}
+		res, err := cli.ContainerCreate(ctx, containerCfg, nil, nil, containerName)
+		if err != nil {
+			return err
+		}
+		log.Println("Created container ID:", res)
+		log.Println("Starting container test")
+
+		cr, _, err := cli.CopyFromContainer(ctx, res.ID, "/buildme/dist.tar.gz")
+		if err != nil {
+			log.Println("Copy error", err)
+			return err
+		}
+		defer cr.Close()
+
+		log.Println("Creating writing file")
+		f, err := os.OpenFile("test.tar.gz", os.O_CREATE|os.O_WRONLY, os.FileMode(0600))
+		if err != nil {
+			log.Println("Error opening file", err)
+			return err
+		}
+		defer f.Close()
+
+		io.Copy(f, cr)
+		f.Sync()
+
+		/*err = cli.ContainerStart(ctx, res.ID, types.ContainerStartOptions{AttachStdout: true})
+		if err != nil {
+			return err
+		}*/
+
+		log.Println("Please execute docker run", containerName, "> dist.tar.gz")
+		log.Println("Trying to remove container", res)
+		err = cli.ContainerRemove(ctx, res.ID, types.ContainerRemoveOptions{})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

src/buildme/fetcher/git/git.go

@@ -21,39 +21,49 @@ func init() {
 	buildme.RegisterFetcher("git", &Git{})
 }
 
-type Git struct {
-}
+type Git struct{}
 
 // Fetcher return a project
 func (g *Git) Fetch(fpath string) (*buildme.Project, error) {
 	log.Println("Building git repo:", fpath)
 
-	projName := filepath.Base(fpath)
+	// File possibilities, does not cover the folder/subfolder
+	if fpath == "." || fpath[0:2] == "./" || fpath[0] == '/' {
+		absPath, err := filepath.Abs(fpath)
+		if err != nil {
+			return nil, err
+		}
+		fpath = "file://" + absPath
+	}
 
-	tmpdir, err := ioutil.TempDir("/tmp", "buildme.")
+	// Create tmpdir to clone project
+	tmpdirname, err := ioutil.TempDir("/tmp", "buildme.")
 	if err != nil {
 		return nil, err
 	}
 
-	log.Println("Cloning to:", tmpdir)
-	git.PlainClone(tmpdir, false, &git.CloneOptions{
-		URL:      fpath,
-		Progress: os.Stdout,
-	})
+	log.Println("Cloning to:", tmpdirname)
+	_, err = git.PlainClone(tmpdirname, false, &git.CloneOptions{URL: fpath, Progress: os.Stdout})
+	if err != nil {
+		log.Println("Err:", err)
+		return nil, err
+	}
+	projName := filepath.Base(fpath)
+	//git.
 
 	log.Println("Taring content")
 
 	/*tarfile, err := ioutil.TempFile("/tmp", "tarbuildme.")
 	reader, err := utils.TarDir(tmpdir, tarfile)*/
-
-	tarFile, err := utils.TempTar(tmpdir, os.TempDir(), "buildme.tar")
+	// Create a temporary tar file from tmpdirname
+	tarFile, err := utils.TempTar(tmpdirname, os.TempDir(), "buildme.tar")
 	log.Println("Tar file:", tarFile.Name())
 
-	log.Println("Removing dir", tmpdir)
-	os.RemoveAll(tmpdir)
+	log.Println("Removing dir", tmpdirname)
+	os.RemoveAll(tmpdirname)
 
 	proj := buildme.NewProject(projName)
-	proj.SetTarFile(tarFile.Name(), true)
+	proj.SetTarFile(tarFile.Name(), true) // Set as temporary will delete as soon as project closes
 
 	return proj, nil
 }

src/buildme/project.go

@@ -1,14 +1,8 @@
 package buildme
 
 import (
-	"context"
-	"fmt"
 	"io"
 	"os"
-
-	"github.com/docker/docker/api/types"
-	"github.com/docker/docker/api/types/container"
-	docker "github.com/docker/docker/client"
 )
 
 // Project type
@@ -57,62 +51,3 @@ func (p *Project) Close() {
 	}
 	//os.Remove(tarFile) // Should remove??
 }
-
-func (p *Project) Docker() error {
-	log.Println("New docker environ")
-	cli, err := docker.NewEnvClient()
-	if err != nil {
-		return err
-	}
-
-	dockertag := fmt.Sprintf("%s-builder", p.Name)
-	log.Println("Building and tagging:", dockertag)
-	///////////////
-	/// DOCKER OPERATION / BUILDER operation
-	ctx := context.Background()
-	{
-		log.Println("Docker image build dockerfile:", p.Dockerfile)
-		imageRes, err := cli.ImageBuild(ctx, p.Reader(), types.ImageBuildOptions{Tags: []string{dockertag}, Dockerfile: p.Dockerfile})
-		if err != nil {
-			return err
-		}
-		defer imageRes.Body.Close()
-		io.Copy(os.Stdout, imageRes.Body) // Do some treatment somehow
-		//inf, err := cli.Info(ctx)
-		//log.Println("Info:", inf, err)
-	}
-
-	{
-
-		log.Println("Testing running the builder")
-		containerName := dockertag
-		containerCfg := &container.Config{AttachStdout: true, Cmd: []string{"cat", "/buildme/dist.tar.gz"}}
-		res, err := cli.ContainerCreate(ctx, containerCfg, nil, nil, containerName)
-		if err != nil {
-			return err
-		}
-		log.Println("Created container ID:", res)
-		log.Println("Starting container test")
-		cr, _, err := cli.CopyFromContainer(ctx, res.ID, "/buildme/dist.tar.gz")
-		if err != nil {
-			log.Println("Copy error", err)
-		}
-		defer cr.Close()
-
-		f, err := os.OpenFile("DIST/test.tar.gz", os.O_CREATE|os.O_WRONLY, os.FileMode(0600))
-		io.Copy(f, cr)
-
-		/*err = cli.ContainerStart(ctx, res.ID, types.ContainerStartOptions{AttachStdout: true})
-		if err != nil {
-			return err
-		}*/
-
-		log.Println("Please execute docker run", containerName, "> dist.tar.gz")
-		log.Println("Trying to remove container", res)
-		err = cli.ContainerRemove(ctx, res.ID, types.ContainerRemoveOptions{})
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}