| package main |
| |
| import ( |
| "bytes" |
| "encoding/base64" |
| "errors" |
| "fmt" |
| "io/ioutil" |
| "os" |
| "path" |
| "path/filepath" |
| "sort" |
| "strings" |
| "text/template" |
| |
| camel "github.com/apache/camel-k/pkg/apis/camel/v1alpha1" |
| "github.com/iancoleman/strcase" |
| "k8s.io/apimachinery/pkg/runtime" |
| "k8s.io/apimachinery/pkg/runtime/schema" |
| "k8s.io/apimachinery/pkg/runtime/serializer" |
| "k8s.io/apimachinery/pkg/util/yaml" |
| ) |
| |
| func main() { |
| if len(os.Args) != 3 { |
| println("usage: generator kamelets-path doc-root") |
| os.Exit(1) |
| } |
| |
| projectBaseDir := os.Args[1] |
| docBaseDir := os.Args[2] |
| |
| funcMap := template.FuncMap{ |
| "ToCamel": strcase.ToCamel, |
| } |
| |
| templateFile := path.Join(docBaseDir, "kamelet.adoc.tmpl") |
| kameletBindingFile := path.Join(docBaseDir, "kamelet-binding-sink-source.tmpl") |
| propertiesListFile := path.Join(docBaseDir, "properties-list.tmpl") |
| |
| |
| |
| docTemplate, err := template.New("kamelet.adoc.tmpl").Funcs(funcMap).ParseFiles(templateFile, kameletBindingFile, propertiesListFile) |
| handleGeneralError(fmt.Sprintf("cannot load template file from %s", templateFile), err) |
| |
| camelKYamlBindingsBaseDir := filepath.Join(projectBaseDir, "templates", "bindings", "camel-k") |
| yamlTemplateFile := path.Join(camelKYamlBindingsBaseDir, "kamelet.yaml.tmpl") |
| |
| yamlTemplate, err := template.New("kamelet.yaml.tmpl").Funcs(funcMap).ParseFiles(yamlTemplateFile, kameletBindingFile, propertiesListFile) |
| handleGeneralError(fmt.Sprintf("cannot load template file from %s", templateFile), err) |
| |
| coreYamlBindingsBaseDir := filepath.Join(projectBaseDir, "templates", "bindings", "core") |
| coreYamlTemplateFile := path.Join(coreYamlBindingsBaseDir, "kamelet-core-binding.yaml.tmpl") |
| parameterListFile := path.Join(coreYamlBindingsBaseDir, "parameter-list.tmpl") |
| |
| coreYamlTemplate, err := template.New("kamelet-core-binding.yaml.tmpl").Funcs(funcMap).ParseFiles(coreYamlTemplateFile, kameletBindingFile, parameterListFile) |
| handleGeneralError(fmt.Sprintf("cannot load template file from %s", templateFile), err) |
| |
| kamelets := listKamelets(projectBaseDir) |
| |
| links := make([]string, 0) |
| for _, k := range kamelets { |
| img := saveImage(k, docBaseDir) |
| |
| ctx := NewTemplateContext(k, img) |
| |
| processDocTemplate(k, docBaseDir, err, docTemplate, &ctx) |
| links = updateImageLink(k, img, links) |
| |
| processYamlTemplate(k, projectBaseDir, err, yamlTemplate, &ctx) |
| processCoreYamlTemplate(k, projectBaseDir, err, coreYamlTemplate, &ctx) |
| |
| } |
| |
| saveNav(links, docBaseDir) |
| } |
| |
| func processDocTemplate(k camel.Kamelet, baseDir string, err error, docTemplate *template.Template, ctx *TemplateContext) { |
| buffer := new(bytes.Buffer) |
| err = docTemplate.Execute(buffer, &ctx) |
| handleGeneralError("cannot process documentation template", err) |
| |
| produceDocFile(k, baseDir, buffer.String()) |
| } |
| |
| func processYamlTemplate(k camel.Kamelet, baseDir string, err error, yamlTemplate *template.Template, ctx *TemplateContext) { |
| buffer := new(bytes.Buffer) |
| err = yamlTemplate.Execute(buffer, ctx) |
| handleGeneralError("cannot process yaml binding template", err) |
| |
| produceBindingFile(k, baseDir, "camel-k", buffer.String()) |
| } |
| |
| func processCoreYamlTemplate(k camel.Kamelet, baseDir string, err error, yamlTemplate *template.Template, ctx *TemplateContext) { |
| buffer := new(bytes.Buffer) |
| err = yamlTemplate.Execute(buffer, ctx) |
| handleGeneralError("cannot process yaml binding template", err) |
| |
| produceBindingFile(k, baseDir, "core", buffer.String()) |
| } |
| |
| func updateImageLink(k camel.Kamelet, img string, links []string) []string { |
| return append(links, fmt.Sprintf("* xref:ROOT:%s.adoc[%s %s]", k.Name, img, k.Spec.Definition.Title)) |
| } |
| |
| type TemplateContext struct { |
| Kamelet camel.Kamelet |
| Image string |
| TemplateProperties map[string]string |
| } |
| |
| func NewTemplateContext(kamelet camel.Kamelet, image string) TemplateContext { |
| return TemplateContext{ |
| Kamelet: kamelet, |
| Image: image, |
| TemplateProperties: map[string]string{}, |
| } |
| } |
| |
| type Prop struct { |
| Name string |
| Title string |
| Required bool |
| Default *string |
| Example *string |
| } |
| |
| func (p Prop) GetSampleValue() string { |
| if p.Default != nil { |
| return *p.Default |
| } |
| if p.Example != nil { |
| return *p.Example |
| } |
| return fmt.Sprintf(`"The %s"`, p.Title) |
| } |
| |
| func getSortedProps(k camel.Kamelet) []Prop { |
| required := make(map[string]bool) |
| props := make([]Prop, 0, len(k.Spec.Definition.Properties)) |
| for _, r := range k.Spec.Definition.Required { |
| required[r] = true |
| } |
| for key := range k.Spec.Definition.Properties { |
| prop := k.Spec.Definition.Properties[key] |
| var def *string |
| if prop.Default != nil { |
| b, err := prop.Default.MarshalJSON() |
| handleGeneralError(fmt.Sprintf("cannot marshal property %q default value in Kamelet %s", key, k.Name), err) |
| defVal := string(b) |
| def = &defVal |
| } |
| var ex *string |
| if prop.Example != nil { |
| b, err := prop.Example.MarshalJSON() |
| handleGeneralError(fmt.Sprintf("cannot marshal property %q example value in Kamelet %s", key, k.Name), err) |
| exVal := string(b) |
| ex = &exVal |
| } |
| props = append(props, Prop{Name: key, Title: prop.Title, Required: required[key], Default: def, Example: ex}) |
| } |
| sort.Slice(props, func(i, j int) bool { |
| ri := props[i].Required |
| rj := props[j].Required |
| if ri && !rj { |
| return true |
| } else if !ri && rj { |
| return false |
| } |
| return props[i].Name < props[j].Name |
| }) |
| return props |
| } |
| |
| func (ctx *TemplateContext) HasProperties() bool { |
| return len(ctx.Kamelet.Spec.Definition.Properties) > 0 |
| } |
| |
| func (ctx *TemplateContext) HasRequiredProperties() bool { |
| propDefs := getSortedProps(ctx.Kamelet) |
| |
| for _, propDef := range propDefs { |
| if propDef.Required { |
| return true |
| } |
| } |
| |
| return false |
| } |
| |
| func (ctx *TemplateContext) PropertyList() string { |
| propDefs := getSortedProps(ctx.Kamelet) |
| |
| sampleConfig := make([]string, 0) |
| for _, propDef := range propDefs { |
| if !propDef.Required { |
| continue |
| } |
| key := propDef.Name |
| if propDef.Default == nil { |
| ex := propDef.GetSampleValue() |
| sampleConfig = append(sampleConfig, fmt.Sprintf("%s: %s", key, ex)) |
| } |
| } |
| |
| /* |
| Creates the properties list in the YAML format. |
| */ |
| props := "" |
| if len(sampleConfig) > 0 { |
| props = fmt.Sprintf("\n %s:\n %s", "properties", strings.Join(sampleConfig, "\n ")) |
| } |
| |
| return props |
| } |
| |
| func (ctx *TemplateContext) ParameterList() string { |
| tp := ctx.Kamelet.ObjectMeta.Labels["camel.apache.org/kamelet.type"] |
| propDefs := getSortedProps(ctx.Kamelet) |
| |
| sampleConfig := make([]string, 0) |
| for _, propDef := range propDefs { |
| if !propDef.Required { |
| continue |
| } |
| key := propDef.Name |
| if propDef.Default == nil { |
| ex := propDef.GetSampleValue() |
| sampleConfig = append(sampleConfig, fmt.Sprintf("%s: %s", key, ex)) |
| } |
| } |
| |
| props := "" |
| |
| if len(sampleConfig) > 0 { |
| paddingSpace := "" |
| switch tp { |
| case "sink": |
| props = fmt.Sprintf("\n%10s%s:\n%12s%s", "", "parameters", |
| "", strings.Join(sampleConfig, fmt.Sprintf("\n%12s", ""))) |
| case "source": |
| props = fmt.Sprintf("\n%6s%s:\n%8s%s", "", "parameters", |
| "", strings.Join(sampleConfig, fmt.Sprintf("\n%8s", ""))) |
| case "action": |
| props = fmt.Sprintf("\n%10s%s:\n%12s%s", paddingSpace, "parameters", |
| "", strings.Join(sampleConfig, fmt.Sprintf("\n%8s", ""))) |
| } |
| } |
| |
| return props |
| } |
| |
| func (ctx *TemplateContext) SetVal(key, val string) string { |
| ctx.TemplateProperties[key] = val |
| return "" |
| } |
| |
| func (ctx *TemplateContext) GetVal(key string) string { |
| return ctx.TemplateProperties[key] |
| } |
| |
| func (ctx *TemplateContext) Properties() string { |
| content := "" |
| if len(ctx.Kamelet.Spec.Definition.Properties) > 0 { |
| props := getSortedProps(ctx.Kamelet) |
| content += `[width="100%",cols="2,^2,3,^2,^2,^3",options="header"]` + "\n" |
| content += "|===\n" |
| content += tableLine("Property", "Name", "Description", "Type", "Default", "Example") |
| |
| for _, propDef := range props { |
| key := propDef.Name |
| prop := ctx.Kamelet.Spec.Definition.Properties[key] |
| name := key |
| if propDef.Required { |
| name = "*" + name + " {empty}* *" |
| } |
| var def string |
| if propDef.Default != nil { |
| def = "`" + strings.ReplaceAll(*propDef.Default, "`", "'") + "`" |
| } |
| var ex string |
| if propDef.Example != nil { |
| ex = "`" + strings.ReplaceAll(*propDef.Example, "`", "'") + "`" |
| } |
| content += tableLine(name, prop.Title, prop.Description, prop.Type, def, ex) |
| } |
| |
| content += "|===\n" |
| |
| } |
| return content |
| } |
| |
| func (ctx *TemplateContext) ExampleKamelBindCommand(ref string) string { |
| tp := ctx.Kamelet.ObjectMeta.Labels["camel.apache.org/kamelet.type"] |
| var prefix string |
| switch tp { |
| case "source": |
| prefix = "source." |
| case "sink": |
| prefix = "sink." |
| case "action": |
| prefix = "step-0." |
| default: |
| handleGeneralError("unknown kamelet type", errors.New(tp)) |
| } |
| |
| cmd := "kamel bind " |
| timer := "timer-source?message=Hello" |
| kamelet := ctx.Kamelet.Name |
| propDefs := getSortedProps(ctx.Kamelet) |
| for _, p := range propDefs { |
| if p.Required && p.Default == nil { |
| val := p.GetSampleValue() |
| if strings.HasPrefix(val, `"`) { |
| kamelet += fmt.Sprintf(` -p "%s%s=%s`, prefix, p.Name, val[1:]) |
| } else { |
| kamelet += fmt.Sprintf(" -p %s%s=%s", prefix, p.Name, val) |
| } |
| } |
| } |
| |
| switch tp { |
| case "source": |
| return cmd + kamelet + " " + ref |
| case "sink": |
| return cmd + ref + " " + kamelet |
| case "action": |
| return cmd + timer + " --step " + kamelet + " " + ref |
| default: |
| handleGeneralError("unknown kamelet type", errors.New(tp)) |
| } |
| return "" |
| } |
| |
| func saveNav(links []string, out string) { |
| content := "// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT\n" |
| for _, l := range links { |
| content += l + "\n" |
| } |
| content += "// THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT\n" |
| dest := filepath.Join(out, "nav.adoc") |
| if _, err := os.Stat(dest); err == nil { |
| err = os.Remove(dest) |
| handleGeneralError(fmt.Sprintf("cannot remove file %q", dest), err) |
| } |
| err := ioutil.WriteFile(dest, []byte(content), 0666) |
| handleGeneralError(fmt.Sprintf("cannot write file %q", dest), err) |
| fmt.Printf("%q written\n", dest) |
| } |
| |
| func saveImage(k camel.Kamelet, out string) string { |
| if ic, ok := k.ObjectMeta.Annotations["camel.apache.org/kamelet.icon"]; ok { |
| svgb64Prefix := "data:image/svg+xml;base64," |
| if strings.HasPrefix(ic, svgb64Prefix) { |
| data := ic[len(svgb64Prefix):] |
| decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data)) |
| iconContent, err := ioutil.ReadAll(decoder) |
| handleGeneralError(fmt.Sprintf("cannot decode icon from Kamelet %s", k.Name), err) |
| dest := filepath.Join(out, "assets", "images", "kamelets", fmt.Sprintf("%s.svg", k.Name)) |
| if _, err := os.Stat(dest); err == nil { |
| err = os.Remove(dest) |
| handleGeneralError(fmt.Sprintf("cannot remove file %q", dest), err) |
| } |
| err = ioutil.WriteFile(dest, iconContent, 0666) |
| handleGeneralError(fmt.Sprintf("cannot write file %q", dest), err) |
| fmt.Printf("%q written\n", dest) |
| return fmt.Sprintf("image:kamelets/%s.svg[]", k.Name) |
| } |
| } |
| return "" |
| } |
| |
| func produceDocFile(k camel.Kamelet, baseDir string, content string) { |
| outputDir := filepath.Join(baseDir, "pages") |
| |
| produceOutputFile(k, outputDir, content,".adoc") |
| } |
| |
| func produceBindingFile(k camel.Kamelet, baseDir string, projectName string, content string) { |
| camelKOutputDir := filepath.Join(baseDir, "templates", "bindings", projectName) |
| |
| produceOutputFile(k, camelKOutputDir, content,"-binding.yaml") |
| } |
| |
| func produceOutputFile(k camel.Kamelet, outputDir string, content string, extension string) { |
| outputFile := filepath.Join(outputDir, k.Name + extension) |
| if _, err := os.Stat(outputFile); err == nil { |
| err = os.Remove(outputFile) |
| handleGeneralError(fmt.Sprintf("cannot remove file %q", outputFile), err) |
| } |
| err := ioutil.WriteFile(outputFile, []byte(content), 0666) |
| handleGeneralError(fmt.Sprintf("cannot write to file %q", outputFile), err) |
| fmt.Printf("%q written\n", outputFile) |
| } |
| |
| func tableLine(val ...string) string { |
| res := "" |
| for _, s := range val { |
| clean := strings.ReplaceAll(s, "|", "\\|") |
| res += "| " + clean |
| } |
| return res + "\n" |
| } |
| |
| func listKamelets(dir string) []camel.Kamelet { |
| scheme := runtime.NewScheme() |
| err := camel.AddToScheme(scheme) |
| handleGeneralError("cannot to add camel APIs to scheme", err) |
| |
| codecs := serializer.NewCodecFactory(scheme) |
| gv := camel.SchemeGroupVersion |
| gvk := schema.GroupVersionKind{ |
| Group: gv.Group, |
| Version: gv.Version, |
| Kind: "Kamelet", |
| } |
| decoder := codecs.UniversalDecoder(gv) |
| |
| kamelets := make([]camel.Kamelet, 0) |
| files, err := ioutil.ReadDir(dir) |
| filesSorted := make([]string, 0) |
| handleGeneralError(fmt.Sprintf("cannot list dir %q", dir), err) |
| for _, fd := range files { |
| if !fd.IsDir() && strings.HasSuffix(fd.Name(), ".kamelet.yaml") { |
| fullName := filepath.Join(dir, fd.Name()) |
| filesSorted = append(filesSorted, fullName) |
| } |
| } |
| sort.Strings(filesSorted) |
| for _, fileName := range filesSorted { |
| content, err := ioutil.ReadFile(fileName) |
| handleGeneralError(fmt.Sprintf("cannot read file %q", fileName), err) |
| |
| json, err := yaml.ToJSON(content) |
| handleGeneralError(fmt.Sprintf("cannot convert file %q to JSON", fileName), err) |
| |
| kamelet := camel.Kamelet{} |
| _, _, err = decoder.Decode(json, &gvk, &kamelet) |
| handleGeneralError(fmt.Sprintf("cannot unmarshal file %q into Kamelet", fileName), err) |
| kamelets = append(kamelets, kamelet) |
| } |
| return kamelets |
| } |
| |
| func handleGeneralError(desc string, err error) { |
| if err != nil { |
| fmt.Printf("%s: %+v\n", desc, err) |
| os.Exit(2) |
| } |
| } |
