wp-s3-action/plugin/impl.go

package plugin

import (
	"context"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/rs/zerolog/log"
)

var ErrTypeAssertionFailed = errors.New("type assertion failed")

// Execute provides the implementation of the plugin.
//
//nolint:revive
func (p *Plugin) run(ctx context.Context) error {
	if err := p.Validate(); err != nil {
		return fmt.Errorf("validation failed: %w", err)
	}

	if err := p.Execute(); err != nil {
		return fmt.Errorf("execution failed: %w", err)
	}

	return nil
}

// Validate handles the settings validation of the plugin.
func (p *Plugin) Validate() error {
	wd, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("error while retrieving working directory: %w", err)
	}

	p.Settings.Source = filepath.Join(wd, p.Settings.Source)
	p.Settings.Target = strings.TrimPrefix(p.Settings.Target, "/")

	return nil
}

// Execute provides the implementation of the plugin.
func (p *Plugin) Execute() error {
	p.Settings.Jobs = make([]Job, 1)
	p.Settings.Client = NewAWS(p)

	if err := p.createSyncJobs(); err != nil {
		return fmt.Errorf("error while creating sync job: %w", err)
	}

	if len(p.Settings.CloudFrontDistribution) > 0 {
		p.Settings.Jobs = append(p.Settings.Jobs, Job{
			local:  "",
			remote: filepath.Join("/", p.Settings.Target, "*"),
			action: "invalidateCloudFront",
		})
	}

	if err := p.runJobs(); err != nil {
		return fmt.Errorf("error while creating sync job: %w", err)
	}

	return nil
}

func (p *Plugin) createSyncJobs() error {
	remote, err := p.Settings.Client.List(p.Settings.Target)
	if err != nil {
		return err
	}

	local := make([]string, 0)

	err = filepath.Walk(p.Settings.Source, func(path string, info os.FileInfo, err error) error {
		if err != nil || info.IsDir() {
			return err
		}

		localPath := path
		if p.Settings.Source != "." {
			localPath = strings.TrimPrefix(path, p.Settings.Source)
			localPath = strings.TrimPrefix(localPath, "/")
		}

		local = append(local, localPath)

		p.Settings.Jobs = append(p.Settings.Jobs, Job{
			local:  filepath.Join(p.Settings.Source, localPath),
			remote: filepath.Join(p.Settings.Target, localPath),
			action: "upload",
		})

		return nil
	})
	if err != nil {
		return err
	}

	for path, location := range p.Settings.Redirects {
		path = strings.TrimPrefix(path, "/")
		local = append(local, path)
		p.Settings.Jobs = append(p.Settings.Jobs, Job{
			local:  path,
			remote: location,
			action: "redirect",
		})
	}

	if p.Settings.Delete {
		for _, remote := range remote {
			found := false
			remotePath := strings.TrimPrefix(remote, p.Settings.Target+"/")

			for _, l := range local {
				if l == remotePath {
					found = true

					break
				}
			}

			if !found {
				p.Settings.Jobs = append(p.Settings.Jobs, Job{
					local:  "",
					remote: remote,
					action: "delete",
				})
			}
		}
	}

	return nil
}

func (p *Plugin) runJobs() error {
	client := p.Settings.Client
	jobChan := make(chan struct{}, p.Settings.MaxConcurrency)
	results := make(chan *Result, len(p.Settings.Jobs))

	var invalidateJob *Job

	log.Info().Msgf("Synchronizing with bucket '%s'", p.Settings.Bucket)

	for _, job := range p.Settings.Jobs {
		jobChan <- struct{}{}

		go func(job Job) {
			var err error

			switch job.action {
			case "upload":
				err = client.Upload(job.local, job.remote)
			case "redirect":
				err = client.Redirect(job.local, job.remote)
			case "delete":
				err = client.Delete(job.remote)
			case "invalidateCloudFront":
				invalidateJob = &job
			default:
				err = nil
			}
			results <- &Result{job, err}

			<-jobChan
		}(job)
	}

	for range p.Settings.Jobs {
		r := <-results
		if r.err != nil {
			return fmt.Errorf("failed to %s %s to %s: %w", r.j.action, r.j.local, r.j.remote, r.err)
		}
	}

	if invalidateJob != nil {
		err := client.Invalidate(invalidateJob.remote)
		if err != nil {
			return fmt.Errorf("failed to %s %s to %s: %w", invalidateJob.action, invalidateJob.local, invalidateJob.remote, err)
		}
	}

	return nil
}