393 lines
9.9 KiB
Go
393 lines
9.9 KiB
Go
// Copyright 2024 Matthew Rich <matthewrich.conf@gmail.com>. All rights reserved.
|
|
|
|
package client
|
|
|
|
import (
|
|
"decl/internal/data"
|
|
"decl/internal/folio"
|
|
_ "decl/internal/fan"
|
|
_ "decl/internal/config"
|
|
_ "decl/internal/resource"
|
|
"decl/internal/fs"
|
|
"decl/internal/builtin"
|
|
"errors"
|
|
"fmt"
|
|
"context"
|
|
"log/slog"
|
|
"os"
|
|
)
|
|
|
|
|
|
var (
|
|
ErrFailedResources error = errors.New("Failed Resources")
|
|
ErrFailedDocuments error = errors.New("Document errors")
|
|
)
|
|
|
|
type App struct {
|
|
Target folio.URI
|
|
ImportedMap map[folio.URI]data.Document
|
|
Documents []data.Document
|
|
emitter data.Converter
|
|
merged data.Document
|
|
Config data.Document
|
|
}
|
|
|
|
func NewClient() *App {
|
|
a := &App{ ImportedMap: make(map[folio.URI]data.Document), Documents: make([]data.Document, 0, 100) }
|
|
return a
|
|
}
|
|
|
|
// Load compiled-in config documents.
|
|
func (a *App) BuiltInConfiguration() (err error) {
|
|
var defaultConfigurations []data.Document
|
|
if defaultConfigurations, err = builtin.BuiltInDocuments(); len(defaultConfigurations) > 0 {
|
|
slog.Info("Client.BuiltInConfiguration()", "documents", defaultConfigurations, "error", err)
|
|
a.Config.AppendConfigurations(defaultConfigurations)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Load config documents from default system config path. Ignore if missing.
|
|
func (a *App) SystemConfiguration(configPath string) (err error) {
|
|
var extractor data.Converter
|
|
var sourceResource data.Resource
|
|
if a.Config == nil {
|
|
a.Config = folio.DocumentRegistry.NewDocument("file:///etc/jx/runtimeconfig.jx.yaml")
|
|
}
|
|
if configPath != "" {
|
|
//configURI := folio.URI(configPath)
|
|
var loaded []data.Document
|
|
docFs := fs.NewWalkDir(os.DirFS(configPath), configPath, func(fsys fs.FS, path string, file fs.DirEntry) (loadErr error) {
|
|
u := folio.URI(fmt.Sprintf("file://%s", path))
|
|
|
|
if ! file.IsDir() {
|
|
slog.Info("Client.SystemConfiguration()", "uri", u)
|
|
if extractor, loadErr = folio.DocumentRegistry.ConverterTypes.New(string(u)); loadErr == nil {
|
|
if sourceResource, loadErr = u.NewResource(nil); loadErr == nil {
|
|
if loaded, loadErr = extractor.(data.ManyExtractor).ExtractMany(sourceResource, nil); loadErr == nil {
|
|
a.Config.AppendConfigurations(loaded)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
})
|
|
err = docFs.Walk(nil)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) MergeDocuments() {
|
|
a.merged = folio.DocumentRegistry.NewDocument("file://-")
|
|
for _, d := range a.Documents {
|
|
for _, declaration := range d.(*folio.Document).ResourceDeclarations {
|
|
a.merged.AddDeclaration((data.Declaration)(declaration))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (a *App) SetOutput(uri string) (err error) {
|
|
if uri == "-" {
|
|
uri = "jx://-"
|
|
}
|
|
a.Target = folio.URI(uri)
|
|
if a.emitter, err = folio.DocumentRegistry.ConverterTypes.New(uri); err != nil {
|
|
return fmt.Errorf("Failed opening target: %s, %w", uri, err)
|
|
}
|
|
slog.Info("Client.SetOutput()", "uri", uri, "emitter", a.emitter)
|
|
return
|
|
}
|
|
|
|
// Each document has an `imports` keyword which can be used to load dependencies
|
|
func (a *App) LoadDocumentImports() error {
|
|
slog.Info("Client.LoadDocumentImports()", "documents", a.Documents)
|
|
for i, d := range a.Documents {
|
|
importedDocs := d.ImportedDocuments()
|
|
slog.Info("Client.LoadDocumentImports()", "imported", importedDocs)
|
|
for _, importedDocument := range importedDocs {
|
|
docURI := folio.URI(importedDocument.GetURI())
|
|
if _, ok := a.ImportedMap[docURI]; !ok {
|
|
a.ImportedMap[docURI] = importedDocument
|
|
a.Documents = append(a.Documents, nil)
|
|
copy(a.Documents[i+1:], a.Documents[i:])
|
|
a.Documents[i] = importedDocument
|
|
/*
|
|
if _, outputErr := a.emitter.Emit(importedDocument, nil); outputErr != nil {
|
|
return outputErr
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
|
|
func (a *App) ImportResource(ctx context.Context, uri string) (err error) {
|
|
if len(a.Documents) < 1 {
|
|
a.Documents = append(a.Documents, folio.DocumentRegistry.NewDocument(""))
|
|
}
|
|
resourceURI := folio.URI(uri)
|
|
u := resourceURI.Parse().URL()
|
|
if u == nil {
|
|
return fmt.Errorf("Failed adding resource: %s", uri)
|
|
}
|
|
if u.Scheme == "" {
|
|
u.Scheme = "file"
|
|
}
|
|
|
|
for _, d := range a.Documents {
|
|
if newResource, newResourceErr := d.NewResource(uri); newResourceErr == nil {
|
|
if _, err = newResource.Read(ctx); err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
return newResourceErr
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) ImportSource(uri string) (loadedDocuments []data.Document, err error) {
|
|
if source := folio.URI(uri).Parse().URL(); source != nil {
|
|
if source.Scheme == "" {
|
|
source.Scheme = "file"
|
|
}
|
|
|
|
slog.Info("Client.ImportSource()", "uri", uri, "source", source, "error", err)
|
|
if loadedDocuments, err = folio.DocumentRegistry.LoadFromParsedURI(source); err == nil && loadedDocuments != nil {
|
|
a.Documents = append(a.Documents, loadedDocuments...)
|
|
}
|
|
} else {
|
|
err = folio.ErrInvalidURI
|
|
}
|
|
|
|
slog.Info("Client.ImportSource()", "uri", uri, "error", err)
|
|
return
|
|
}
|
|
|
|
func (a *App) Import(docs []string) (err error) {
|
|
for _, source := range docs {
|
|
if _, err = a.ImportSource(source); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) Apply(ctx context.Context, deleteResources bool) (err error) {
|
|
var errorsCount int = 0
|
|
for _, d := range a.Documents {
|
|
d.SetConfig(a.Config)
|
|
|
|
var overrideState string = ""
|
|
if deleteResources {
|
|
overrideState = "delete"
|
|
}
|
|
d.ResolveIds(ctx)
|
|
|
|
_ = d.Apply("stat")
|
|
|
|
if ! d.CheckConstraints() {
|
|
slog.Info("Client.Apply() document constraints failed", "requires", d)
|
|
d.AddError(fmt.Errorf("%w: %s", folio.ErrConstraintFailure, d.GetURI()))
|
|
errorsCount++
|
|
continue
|
|
}
|
|
|
|
slog.Info("Client.Apply()", "uri", d.GetURI(), "document", d, "state", overrideState, "error", err)
|
|
if e := d.(*folio.Document).Apply(overrideState); e != nil {
|
|
slog.Info("Client.Apply() error", "error", e)
|
|
return e
|
|
}
|
|
if d.Failures() > 0 {
|
|
d.AddError(fmt.Errorf("%w: %d, %w", ErrFailedResources, d.Failures(), err))
|
|
errorsCount++
|
|
}
|
|
}
|
|
|
|
if errorsCount > 0 {
|
|
return fmt.Errorf("%w: %d", ErrFailedDocuments, errorsCount)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) ImportCmd(ctx context.Context, docs []string, resourceURI string, quiet bool, merge bool) (err error) {
|
|
defer a.Close()
|
|
if err = a.Import(docs); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = a.LoadDocumentImports(); err != nil {
|
|
return
|
|
}
|
|
|
|
if len(resourceURI) > 0 {
|
|
if err = a.ImportResource(ctx, resourceURI); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
if quiet {
|
|
err = a.Quiet()
|
|
} else {
|
|
if merge {
|
|
a.MergeDocuments()
|
|
}
|
|
err = a.Emit()
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) ApplyCmd(ctx context.Context, docs []string, quiet bool, deleteResources bool) (err error) {
|
|
defer a.Close()
|
|
var failedResources error
|
|
if err = a.Import(docs); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = a.LoadDocumentImports(); err != nil {
|
|
return
|
|
}
|
|
|
|
if failedResources = a.Apply(ctx, deleteResources); failedResources != nil {
|
|
slog.Info("Client.ApplyCmd()", "client", a, "error", failedResources)
|
|
if ! errors.Is(failedResources, ErrFailedResources) && ! errors.Is(failedResources, ErrFailedDocuments) {
|
|
return failedResources
|
|
}
|
|
}
|
|
|
|
if quiet {
|
|
err = a.Quiet()
|
|
} else {
|
|
err = a.Emit()
|
|
}
|
|
|
|
if failedResources != nil {
|
|
if err != nil {
|
|
return fmt.Errorf("%w %w", failedResources, err)
|
|
} else {
|
|
return failedResources
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (a *App) Diff(left []data.Document, right []data.Document) (err error) {
|
|
output := os.Stdout
|
|
slog.Info("jx diff ", "right", right, "left", left)
|
|
index := 0
|
|
for {
|
|
if index >= len(right) && index >= len(left) {
|
|
break
|
|
}
|
|
if index >= len(right) {
|
|
if _, err = left[index].Diff(folio.DocumentRegistry.NewDocument(""), output); err != nil {
|
|
return
|
|
}
|
|
index++
|
|
continue
|
|
}
|
|
if index >= len(left) {
|
|
if _, err = folio.DocumentRegistry.NewDocument("").Diff(right[index], output); err != nil {
|
|
return
|
|
}
|
|
index++
|
|
continue
|
|
}
|
|
if _, err = left[index].Diff(right[index], output); err != nil {
|
|
return
|
|
}
|
|
index++
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) DiffCmd(docs []string) (err error) {
|
|
output := os.Stdout
|
|
|
|
var leftDocuments, rightDocuments []data.Document
|
|
var rightSource folio.URI
|
|
|
|
//leftSource := folio.URI(docs[0])
|
|
if len(docs) > 1 {
|
|
rightSource = folio.URI(docs[1])
|
|
}
|
|
|
|
if leftDocuments, err = a.ImportSource(docs[0]); err == nil {
|
|
if rightSource.IsEmpty() {
|
|
for _, doc := range leftDocuments {
|
|
_, err = doc.DiffState(output)
|
|
}
|
|
} else {
|
|
if rightDocuments, err = a.ImportSource(docs[1]); err == nil {
|
|
err = a.Diff(leftDocuments, rightDocuments)
|
|
}
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (a *App) ConfigCmd(docs []string, includeSystemConfig bool) (err error) {
|
|
defer a.Close()
|
|
if err = a.BuiltInConfiguration(); err != nil {
|
|
slog.Warn("BuiltInConfiguration()", "error", err)
|
|
}
|
|
|
|
if err = a.Import(docs); err != nil {
|
|
return
|
|
}
|
|
|
|
if err = a.LoadDocumentImports(); err != nil {
|
|
return
|
|
}
|
|
|
|
if includeSystemConfig {
|
|
if _, err = a.emitter.Emit(a.Config, nil); err != nil {
|
|
return
|
|
}
|
|
}
|
|
_, err = a.emitter.(data.ManyEmitter).EmitMany(a.Documents, nil)
|
|
return
|
|
}
|
|
|
|
func (a *App) Quiet() (err error) {
|
|
output := os.Stdout
|
|
for _, d := range a.Documents {
|
|
for _, dr := range d.Declarations() {
|
|
if _, err = output.Write([]byte(fmt.Sprintf("%s\n", dr.Resource().URI()))); err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) Emit() (err error) {
|
|
if a.merged == nil {
|
|
for _, d := range a.Documents {
|
|
slog.Info("Client.Emit() document", "document", d)
|
|
if _, err = a.emitter.Emit(d, nil); err != nil {
|
|
return
|
|
}
|
|
}
|
|
} else {
|
|
if _, err = a.emitter.Emit(a.merged, nil); err != nil {
|
|
return
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (a *App) Close() (err error) {
|
|
if a.emitter != nil {
|
|
slog.Info("Client.Close() emitter", "emitter", a.emitter)
|
|
return a.emitter.Close()
|
|
}
|
|
return
|
|
}
|