hunk.code_window: 	if err != nil {
   		return errors.Wrap(err, "failed to create env file")
   	}
   	filePaths := stackutils.GetStackFilePaths(stack, false)
   	err = manager.deployer.Pull(ctx, filePaths, libstack.Options{
   		WorkingDir:  stack.ProjectPath,
   		EnvFilePath: envFilePath,
   		Host:        url,
   		ProjectName: stack.Name,
  
hunk.labels: keep keep keep keep replace keep keep keep keep keep
hunk.after_edit: 	filePaths := stackutils.GetStackFilePaths(stack, true)
  
hunk.file_path: api/exec/compose_stack.go
hunk.type: replace
file: package exec
  
  import (
  	"context"
  	"fmt"
  	"io"
  	"os"
  	"path"
  	"strings"
  
  	libstack "github.com/portainer/docker-compose-wrapper"
  	portainer "github.com/portainer/portainer/api"
  	"github.com/portainer/portainer/api/http/proxy"
  	"github.com/portainer/portainer/api/http/proxy/factory"
  	"github.com/portainer/portainer/api/stacks/stackutils"
  
  	"github.com/pkg/errors"
  )
  
  // ComposeStackManager is a wrapper for docker-compose binary
  type ComposeStackManager struct {
  	deployer     libstack.Deployer
  	proxyManager *proxy.Manager
  }
  
  // NewComposeStackManager returns a docker-compose wrapper if corresponding binary present, otherwise nil
  func NewComposeStackManager(deployer libstack.Deployer, proxyManager *proxy.Manager) (*ComposeStackManager, error) {
  
  	return &ComposeStackManager{
  		deployer:     deployer,
  		proxyManager: proxyManager,
  	}, nil
  }
  
  // ComposeSyntaxMaxVersion returns the maximum supported version of the docker compose syntax
  func (manager *ComposeStackManager) ComposeSyntaxMaxVersion() string {
  	return portainer.ComposeSyntaxMaxVersion
  }
  
  // Up builds, (re)creates and starts containers in the background. Wraps `docker-compose up -d` command
  func (manager *ComposeStackManager) Up(ctx context.Context, stack *portainer.Stack, endpoint *portainer.Endpoint, forceRecreate bool) error {
  	url, proxy, err := manager.fetchEndpointProxy(endpoint)
  	if err != nil {
  		return errors.Wrap(err, "failed to fetch environment proxy")
  	}
  
  	if proxy != nil {
  		defer proxy.Close()
  	}
  
  	envFilePath, err := createEnvFile(stack)
  	if err != nil {
  		return errors.Wrap(err, "failed to create env file")
  	}
  
  	filePaths := stackutils.GetStackFilePaths(stack, false)
  	err = manager.deployer.Deploy(ctx, filePaths, libstack.DeployOptions{
  		Options: libstack.Options{
  			WorkingDir:  stack.ProjectPath,
  			EnvFilePath: envFilePath,
  			Host:        url,
  			ProjectName: stack.Name,
  		},
  		ForceRecreate: forceRecreate,
  	})
  	return errors.Wrap(err, "failed to deploy a stack")
  }
  
  // Down stops and removes containers, networks, images, and volumes
  func (manager *ComposeStackManager) Down(ctx context.Context, stack *portainer.Stack, endpoint *portainer.Endpoint) error {
  	url, proxy, err := manager.fetchEndpointProxy(endpoint)
  	if err != nil {
  		return err
  	}
  	if proxy != nil {
  		defer proxy.Close()
  	}
  
  	envFilePath, err := createEnvFile(stack)
  	if err != nil {
  		return errors.Wrap(err, "failed to create env file")
  	}
  
  	err = manager.deployer.Remove(ctx, stack.Name, nil, libstack.Options{
  		WorkingDir:  stack.ProjectPath,
  		EnvFilePath: envFilePath,
  		Host:        url,
  	})
  
  	return errors.Wrap(err, "failed to remove a stack")
  }
  
  // Pull an image associated with a service defined in a docker-compose.yml or docker-stack.yml file,
  // but does not start containers based on those images.
  func (manager *ComposeStackManager) Pull(ctx context.Context, stack *portainer.Stack, endpoint *portainer.Endpoint) error {
  	url, proxy, err := manager.fetchEndpointProxy(endpoint)
  	if err != nil {
  		return err
  	}
  	if proxy != nil {
  		defer proxy.Close()
  	}
  
  	envFilePath, err := createEnvFile(stack)
  	if err != nil {
  		return errors.Wrap(err, "failed to create env file")
  	}
  
  	filePaths := stackutils.GetStackFilePaths(stack, false)
  	err = manager.deployer.Pull(ctx, filePaths, libstack.Options{
  		WorkingDir:  stack.ProjectPath,
  		EnvFilePath: envFilePath,
  		Host:        url,
  		ProjectName: stack.Name,
  	})
  	return errors.Wrap(err, "failed to pull images of the stack")
  }
  
  // NormalizeStackName returns a new stack name with unsupported characters replaced
  func (manager *ComposeStackManager) NormalizeStackName(name string) string {
  	return stackNameNormalizeRegex.ReplaceAllString(strings.ToLower(name), "")
  }
  
  func (manager *ComposeStackManager) fetchEndpointProxy(endpoint *portainer.Endpoint) (string, *factory.ProxyServer, error) {
  	if strings.HasPrefix(endpoint.URL, "unix://") || strings.HasPrefix(endpoint.URL, "npipe://") {
  		return "", nil, nil
  	}
  
  	proxy, err := manager.proxyManager.CreateAgentProxyServer(endpoint)
  	if err != nil {
  		return "", nil, err
  	}
  
  	return fmt.Sprintf("tcp://127.0.0.1:%d", proxy.Port), proxy, nil
  }
  
  // createEnvFile creates a file that would hold both "in-place" and default environment variables.
  // It will return the name of the file if the stack has "in-place" env vars, otherwise empty string.
  func createEnvFile(stack *portainer.Stack) (string, error) {
  	if len(stack.Env) == 0 {
  		return "", nil
  	}
  
  	envFilePath := path.Join(stack.ProjectPath, "stack.env")
  	envfile, err := os.OpenFile(envFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
  	if err != nil {
  		return "", err
  	}
  	defer envfile.Close()
  
  	copyDefaultEnvFile(stack, envfile)
  
  	for _, v := range stack.Env {
  		envfile.WriteString(fmt.Sprintf("%s=%s\n", v.Name, v.Value))
  	}
  
  	return "stack.env", nil
  }
  
  // copyDefaultEnvFile copies the default .env file if it exists to the provided writer
  func copyDefaultEnvFile(stack *portainer.Stack, w io.Writer) {
  	defaultEnvFile, err := os.Open(path.Join(path.Join(stack.ProjectPath, path.Dir(stack.EntryPoint)), ".env"))
  	if err != nil {
  		// If cannot open a default file, then don't need to copy it.
  		// We could as well stat it and check if it exists, but this is more efficient.
  		return
  	}
  
  	defer defaultEnvFile.Close()
  
  	if _, err = io.Copy(w, defaultEnvFile); err == nil {
  		io.WriteString(w, "\n")
  	}
  	// If couldn't copy the .env file, then ignore the error and try to continue
  }
  