I guess this is to be replaced with the buildkit equivalent, so we should look if that one needs refactoring;

Lines 43 to 189 in ab50c2f

    
           func runBuildBuildKit(dockerCli command.Cli, options buildOptions) error { 
        
           	ctx := appcontext.Context() 
        
           	s, err := trySession(dockerCli, options.context) 
        
           	if err != nil { 
        
           		return err 
        
           	} 
        
           	if s == nil { 
        
           		return errors.Errorf("buildkit not supported by daemon") 
        
           	} 
        
           	if options.imageIDFile != "" { 
        
           		// Avoid leaving a stale file if we eventually fail 
        
           		if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) { 
        
           			return errors.Wrap(err, "removing image ID file") 
        
           		} 
        
           	} 
        
           	var ( 
        
           		remote           string 
        
           		body             io.Reader 
        
           		dockerfileName   = options.dockerfileName 
        
           		dockerfileReader io.ReadCloser 
        
           		dockerfileDir    string 
        
           		contextDir       string 
        
           	) 
        
           	switch { 
        
           	case options.contextFromStdin(): 
        
           		if options.dockerfileFromStdin() { 
        
           			return errStdinConflict 
        
           		} 
        
           		rc, isArchive, err := build.DetectArchiveReader(os.Stdin) 
        
           		if err != nil { 
        
           			return err 
        
           		} 
        
           		if isArchive { 
        
           			body = rc 
        
           			remote = uploadRequestRemote 
        
           		} else { 
        
           			if options.dockerfileName != "" { 
        
           				return errDockerfileConflict 
        
           			} 
        
           			dockerfileReader = rc 
        
           			remote = clientSessionRemote 
        
           			// TODO: make fssync handle empty contextdir 
        
           			contextDir, _ = ioutil.TempDir("", "empty-dir") 
        
           			defer os.RemoveAll(contextDir) 
        
           		} 
        
           	case isLocalDir(options.context): 
        
           		contextDir = options.context 
        
           		if options.dockerfileFromStdin() { 
        
           			dockerfileReader = os.Stdin 
        
           		} else if options.dockerfileName != "" { 
        
           			dockerfileName = filepath.Base(options.dockerfileName) 
        
           			dockerfileDir = filepath.Dir(options.dockerfileName) 
        
           		} else { 
        
           			dockerfileDir = options.context 
        
           		} 
        
           		remote = clientSessionRemote 
        
           	case urlutil.IsGitURL(options.context): 
        
           		remote = options.context 
        
           	case urlutil.IsURL(options.context): 
        
           		remote = options.context 
        
           	default: 
        
           		return errors.Errorf("unable to prepare context: path %q not found", options.context) 
        
           	} 
        
           	if dockerfileReader != nil { 
        
           		dockerfileName = build.DefaultDockerfileName 
        
           		dockerfileDir, err = build.WriteTempDockerfile(dockerfileReader) 
        
           		if err != nil { 
        
           			return err 
        
           		} 
        
           		defer os.RemoveAll(dockerfileDir) 
        
           	} 
        
           	if dockerfileDir != "" { 
        
           		s.Allow(filesync.NewFSSyncProvider([]filesync.SyncedDir{ 
        
           			{ 
        
           				Name: "context", 
        
           				Dir:  contextDir, 
        
           				Map:  resetUIDAndGID, 
        
           			}, 
        
           			{ 
        
           				Name: "dockerfile", 
        
           				Dir:  dockerfileDir, 
        
           			}, 
        
           		})) 
        
           	} 
        
           	s.Allow(authprovider.NewDockerAuthProvider()) 
        
           	if len(options.secrets) > 0 { 
        
           		sp, err := parseSecretSpecs(options.secrets) 
        
           		if err != nil { 
        
           			return errors.Wrapf(err, "could not parse secrets: %v", options.secrets) 
        
           		} 
        
           		s.Allow(sp) 
        
           	} 
        
           	if len(options.ssh) > 0 { 
        
           		sshp, err := parseSSHSpecs(options.ssh) 
        
           		if err != nil { 
        
           			return errors.Wrapf(err, "could not parse ssh: %v", options.ssh) 
        
           		} 
        
           		s.Allow(sshp) 
        
           	} 
        
           	eg, ctx := errgroup.WithContext(ctx) 
        
           	eg.Go(func() error { 
        
           		return s.Run(context.TODO(), dockerCli.Client().DialSession) 
        
           	}) 
        
           	buildID := stringid.GenerateRandomID() 
        
           	if body != nil { 
        
           		eg.Go(func() error { 
        
           			buildOptions := types.ImageBuildOptions{ 
        
           				Version: types.BuilderBuildKit, 
        
           				BuildID: uploadRequestRemote + ":" + buildID, 
        
           			} 
        
           			response, err := dockerCli.Client().ImageBuild(context.Background(), body, buildOptions) 
        
           			if err != nil { 
        
           				return err 
        
           			} 
        
           			defer response.Body.Close() 
        
           			return nil 
        
           		}) 
        
           	} 
        
           	eg.Go(func() error { 
        
           		defer func() { // make sure the Status ends cleanly on build errors 
        
           			s.Close() 
        
           		}() 
        
           		buildOptions := imageBuildOptions(dockerCli, options) 
        
           		buildOptions.Version = types.BuilderBuildKit 
        
           		buildOptions.Dockerfile = dockerfileName 
        
           		//buildOptions.AuthConfigs = authConfigs   // handled by session 
        
           		buildOptions.RemoteContext = remote 
        
           		buildOptions.SessionID = s.ID() 
        
           		buildOptions.BuildID = buildID 
        
           		return doBuild(ctx, eg, dockerCli, options, buildOptions) 
        
           	}) 
        
           	return eg.Wait() 
        
           }

, but otherwise; yes, I think we should close for now

	func runBuildBuildKit(dockerCli command.Cli, options buildOptions) error {
	ctx := appcontext.Context()

	s, err := trySession(dockerCli, options.context)
	if err != nil {
	return err
	}
	if s == nil {
	return errors.Errorf("buildkit not supported by daemon")
	}

	if options.imageIDFile != "" {
	// Avoid leaving a stale file if we eventually fail
	if err := os.Remove(options.imageIDFile); err != nil && !os.IsNotExist(err) {
	return errors.Wrap(err, "removing image ID file")
	}
	}

	var (
	remote string
	body io.Reader
	dockerfileName = options.dockerfileName
	dockerfileReader io.ReadCloser
	dockerfileDir string
	contextDir string
	)

	switch {
	case options.contextFromStdin():
	if options.dockerfileFromStdin() {
	return errStdinConflict
	}
	rc, isArchive, err := build.DetectArchiveReader(os.Stdin)
	if err != nil {
	return err
	}
	if isArchive {
	body = rc
	remote = uploadRequestRemote
	} else {
	if options.dockerfileName != "" {
	return errDockerfileConflict
	}
	dockerfileReader = rc
	remote = clientSessionRemote
	// TODO: make fssync handle empty contextdir
	contextDir, _ = ioutil.TempDir("", "empty-dir")
	defer os.RemoveAll(contextDir)
	}
	case isLocalDir(options.context):
	contextDir = options.context
	if options.dockerfileFromStdin() {
	dockerfileReader = os.Stdin
	} else if options.dockerfileName != "" {
	dockerfileName = filepath.Base(options.dockerfileName)
	dockerfileDir = filepath.Dir(options.dockerfileName)
	} else {
	dockerfileDir = options.context
	}
	remote = clientSessionRemote
	case urlutil.IsGitURL(options.context):
	remote = options.context
	case urlutil.IsURL(options.context):
	remote = options.context
	default:
	return errors.Errorf("unable to prepare context: path %q not found", options.context)
	}

	if dockerfileReader != nil {
	dockerfileName = build.DefaultDockerfileName
	dockerfileDir, err = build.WriteTempDockerfile(dockerfileReader)
	if err != nil {
	return err
	}
	defer os.RemoveAll(dockerfileDir)
	}

	if dockerfileDir != "" {
	s.Allow(filesync.NewFSSyncProvider([]filesync.SyncedDir{
	{
	Name: "context",
	Dir: contextDir,
	Map: resetUIDAndGID,
	},
	{
	Name: "dockerfile",
	Dir: dockerfileDir,
	},
	}))
	}

	s.Allow(authprovider.NewDockerAuthProvider())
	if len(options.secrets) > 0 {
	sp, err := parseSecretSpecs(options.secrets)
	if err != nil {
	return errors.Wrapf(err, "could not parse secrets: %v", options.secrets)
	}
	s.Allow(sp)
	}
	if len(options.ssh) > 0 {
	sshp, err := parseSSHSpecs(options.ssh)
	if err != nil {
	return errors.Wrapf(err, "could not parse ssh: %v", options.ssh)
	}
	s.Allow(sshp)
	}

	eg, ctx := errgroup.WithContext(ctx)

	eg.Go(func() error {
	return s.Run(context.TODO(), dockerCli.Client().DialSession)
	})

	buildID := stringid.GenerateRandomID()
	if body != nil {
	eg.Go(func() error {
	buildOptions := types.ImageBuildOptions{
	Version: types.BuilderBuildKit,
	BuildID: uploadRequestRemote + ":" + buildID,
	}

	response, err := dockerCli.Client().ImageBuild(context.Background(), body, buildOptions)
	if err != nil {
	return err
	}
	defer response.Body.Close()
	return nil
	})
	}

	eg.Go(func() error {
	defer func() { // make sure the Status ends cleanly on build errors
	s.Close()
	}()

	buildOptions := imageBuildOptions(dockerCli, options)
	buildOptions.Version = types.BuilderBuildKit
	buildOptions.Dockerfile = dockerfileName
	//buildOptions.AuthConfigs = authConfigs // handled by session
	buildOptions.RemoteContext = remote
	buildOptions.SessionID = s.ID()
	buildOptions.BuildID = buildID
	return doBuild(ctx, eg, dockerCli, options, buildOptions)
	})

	return eg.Wait()
	}

Refactor build/runBuild() #242

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Refactor `build/runBuild()` #242