github.com/taubyte/tau-cli@v0.1.13-0.20240326000942-487f0d57edfc/lib/dream/project.go (about)

     1  package dreamLib
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"os"
     7  	"path"
     8  	"strings"
     9  	"sync"
    10  
    11  	"github.com/pterm/pterm"
    12  	libraryI18n "github.com/taubyte/tau-cli/i18n/library"
    13  	websiteI18n "github.com/taubyte/tau-cli/i18n/website"
    14  	projectLib "github.com/taubyte/tau-cli/lib/project"
    15  )
    16  
    17  func runJobs(jobs []internalJob) error {
    18  	var (
    19  		wg       sync.WaitGroup
    20  		foundErr bool
    21  	)
    22  
    23  	wg.Add(len(jobs))
    24  	for _, job := range jobs {
    25  		go func(_job internalJob) {
    26  			if err := _job(); err != nil {
    27  				foundErr = true
    28  
    29  				pterm.Error.Printfln("job failed: %s", err)
    30  			}
    31  
    32  			wg.Done()
    33  		}(job)
    34  	}
    35  	wg.Wait()
    36  
    37  	if foundErr {
    38  		return errors.New("a job failed")
    39  	}
    40  
    41  	return nil
    42  }
    43  
    44  func (i *ProdProject) Import() error {
    45  	// Attach the project to dreamland
    46  	if err := i.Attach(); err != nil {
    47  		return err
    48  	}
    49  
    50  	h := projectLib.Repository(i.Project.Get().Name())
    51  	projectRepositories, err := h.Open()
    52  	if err != nil {
    53  		return err
    54  	}
    55  
    56  	branch, err := projectRepositories.CurrentBranch()
    57  	if err != nil {
    58  		return err
    59  	}
    60  
    61  	projectConfig, err := projectLib.SelectedProjectConfig()
    62  	if err != nil {
    63  		return err
    64  	}
    65  
    66  	getter := i.Project.Get()
    67  	projectId := getter.Id()
    68  
    69  	internalJobs := make([]internalJob, 0)
    70  	addJob := func(appId, objId, path string) {
    71  		internalJobs = append(internalJobs, func() error {
    72  			job := &CompileForRepository{
    73  				ProjectId:     projectId,
    74  				ApplicationId: appId,
    75  				ResourceId:    objId,
    76  				Branch:        branch,
    77  				Path:          path,
    78  			}
    79  
    80  			return job.Execute()
    81  		})
    82  	}
    83  
    84  	addLibrary := func(name, appName, appID string) error {
    85  		libObj, err := i.Project.Library(name, appName)
    86  		if err != nil {
    87  			return fmt.Errorf("reading library `%s/%s` failed with: %s", appName, name, err)
    88  		}
    89  
    90  		_, _, fullName := libObj.Get().Git()
    91  		libraryPath := path.Join(projectConfig.LibraryLoc(), strings.Split(fullName, "/")[1])
    92  
    93  		if _, err := os.Stat(libraryPath); err != nil {
    94  			libraryI18n.Help().BeSureToCloneLibrary()
    95  			return err
    96  		}
    97  
    98  		addJob(appID, libObj.Get().Id(), libraryPath)
    99  
   100  		return nil
   101  	}
   102  
   103  	addWebsite := func(name, appName, appID string) error {
   104  		webObj, err := i.Project.Website(name, appName)
   105  		if err != nil {
   106  			return fmt.Errorf("reading website `%s/%s` failed with: %s", appName, name, err)
   107  		}
   108  
   109  		_, _, fullName := webObj.Get().Git()
   110  		websitePath := path.Join(projectConfig.WebsiteLoc(), strings.Split(fullName, "/")[1])
   111  
   112  		if _, err := os.Stat(websitePath); err != nil {
   113  			websiteI18n.Help().BeSureToCloneWebsite()
   114  			return err
   115  		}
   116  
   117  		addJob(appID, webObj.Get().Id(), websitePath)
   118  
   119  		return nil
   120  	}
   121  
   122  	// Build config
   123  	b := &BuildLocalConfigCode{
   124  		Config:      true,
   125  		Code:        false,
   126  		Branch:      branch,
   127  		ProjectPath: projectConfig.Location,
   128  		ProjectID:   projectId,
   129  	}
   130  
   131  	if err := b.Execute(); err != nil {
   132  		return fmt.Errorf("building config failed with: %s", err)
   133  	}
   134  
   135  	// Attach building code to the internalJobs
   136  	b.Config = false
   137  	b.Code = true
   138  	internalJobs = append(internalJobs, b.Execute)
   139  
   140  	// Iterate over all global websites and libraries
   141  	_, libraries := getter.Libraries("")
   142  	for _, lib := range libraries {
   143  		if err := addLibrary(lib, "", ""); err != nil {
   144  			return err
   145  		}
   146  	}
   147  
   148  	_, websites := getter.Websites("")
   149  	for _, web := range websites {
   150  		if err := addWebsite(web, "", ""); err != nil {
   151  			return err
   152  		}
   153  	}
   154  
   155  	// Iterate over websites and libraries within applications
   156  	for _, app := range getter.Applications() {
   157  		appObj, err := i.Project.Application(app)
   158  		if err != nil {
   159  			return fmt.Errorf("reading application `%s` failed with: %s", app, err)
   160  		}
   161  		appId := appObj.Get().Id()
   162  
   163  		localLibraries, _ := getter.Libraries(app)
   164  		for _, lib := range localLibraries {
   165  			if err := addLibrary(lib, app, appId); err != nil {
   166  				return err
   167  			}
   168  		}
   169  
   170  		localWebsites, _ := getter.Websites(app)
   171  		for _, web := range localWebsites {
   172  			if err := addWebsite(web, app, appId); err != nil {
   173  				return err
   174  			}
   175  		}
   176  	}
   177  
   178  	return runJobs(internalJobs)
   179  }