Golang Template.ReadmeLink方法代碼示例

func walkVersion(path string, template *model.Template) (bool, bool, error) {
	dirList, err := ioutil.ReadDir(path)

	if err != nil {
		log.Errorf("Error reading template at path: %s, error: %v", path, err)
		return false, false, err
	}

	var foundIcon, foundReadme bool

	for _, subfile := range dirList {
		if strings.HasPrefix(subfile.Name(), "catalogIcon") {
			template.IconLink = template.Id + "?image"
			foundIcon = true
			PathToImage[template.Path] = subfile.Name()

		} else if strings.HasPrefix(strings.ToLower(subfile.Name()), "readme") {
			template.ReadmeLink = template.Id + "?readme"
			foundReadme = true
			PathToReadme[template.Path] = subfile.Name()

		} else {
			//read if its a file and put it in the files map
			if !subfile.IsDir() {
				bytes, err := readFile(path, subfile.Name())
				if err != nil {
					continue
				}
				key := deriveFilePath(template.Path, path) + subfile.Name()

				template.Files[key] = string(*bytes)
				if strings.HasPrefix(subfile.Name(), "rancher-compose") {
					readRancherCompose(path, template)
				}
			} else {
				//grab files under this folder
				walkVersion(path+"/"+subfile.Name(), template)
			}
		}
	}

	return foundIcon, foundReadme, nil
}

//ReadTemplateVersion reads the template version details
func (cat *Catalog) ReadTemplateVersion(templateID string, versionID string) (*model.Template, bool) {

	prefix, templateName := ExtractTemplatePrefixAndName(templateID)
	path := cat.CatalogID + "/" + prefix + "/" + templateName + "/" + versionID
	parentPath := cat.CatalogID + "/" + templateID
	parentMetadata, ok := cat.metadata[parentPath]

	if ok {
		newTemplate := model.Template{}
		newTemplate.Path = cat.CatalogID + "/" + templateID + "/" + versionID
		newTemplate.TemplateBase = parentMetadata.TemplateBase
		newTemplate.Id = cat.CatalogID + ":" + templateID + ":" + versionID
		newTemplate.CatalogID = cat.CatalogID
		newTemplate.DefaultVersion = parentMetadata.DefaultVersion
		newTemplate.Category = parentMetadata.Category
		newTemplate.IsSystem = parentMetadata.IsSystem
		newTemplate.Files = make(map[string]string)

		foundIcon, foundReadme, err := walkVersion(CatalogRootDir+path, &newTemplate)

		if err != nil {
			log.Errorf("Error reading template at path: %s, error: %v", path, err)
			return nil, false
		}

		if !foundIcon {
			//use the parent icon
			newTemplate.IconLink = parentMetadata.IconLink
		}

		if !foundReadme {
			//use the parent readme
			newTemplate.ReadmeLink = parentMetadata.ReadmeLink
		}

		return &newTemplate, true
	}

	return nil, false

}

func (cat *Catalog) walkCatalog(filePath string, f os.FileInfo, err error) error {
	//log.Debugf("Reading folder for template:%s %v", filePath, f)

	if f != nil && f.IsDir() && metadataFolder.MatchString(filePath) {

		//matches ./DATA/catalogID/templates/ElasticSearch or 	./DATA/catalogID/k8s-templates/ElasticSearch
		// get the prefix like 'k8s' if any
		prefix := metadataFolder.ReplaceAllString(filePath, "$2")
		prefixWithSeparator := prefix
		if prefix != "" {
			prefixWithSeparator = prefix + "*"
		}

		log.Debugf("Reading metadata folder for template:%s, path: %v", f.Name(), filePath)
		newTemplate := model.Template{
			Resource: client.Resource{
				Id:   cat.CatalogID + ":" + prefixWithSeparator + f.Name(),
				Type: "template",
			},
			Path:         cat.CatalogID + "/" + prefixWithSeparator + f.Name(), //catalogRoot + prefix + f.Name()
			TemplateBase: prefix,
		}

		//read the root level config.yml
		readTemplateConfig(filePath, &newTemplate)

		//list the folders under the root level
		newTemplate.VersionLinks = make(map[string]string)
		newTemplate.CatalogID = cat.CatalogID
		newTemplate.TemplateVersionRancherVersion = make(map[string]string)
		newTemplate.TemplateVersionRancherVersionGte = make(map[string]string)
		dirList, err := ioutil.ReadDir(filePath)
		if err != nil {
			log.Errorf("Error reading directories at path: %s, error: %v", f.Name(), err)
		} else {
			for _, subfile := range dirList {
				if subfile.IsDir() {
					//read the subversion config.yml file into a template
					subTemplate := model.Template{}
					err := readRancherCompose(path.Join(filePath, subfile.Name()), &subTemplate)
					if err == nil {
						newTemplate.VersionLinks[subTemplate.Version] = newTemplate.Id + ":" + subfile.Name()
						newTemplate.TemplateVersionRancherVersion[subTemplate.Version] = subTemplate.MinimumRancherVersion
						newTemplate.TemplateVersionRancherVersionGte[subTemplate.Version] = subTemplate.MaximumRancherVersion
					} else {
						subfilePath := path.Join(f.Name(), subfile.Name())
						if ValidationMode {
							log.Fatalf("Error processing the template version: %s, error: %v", subfilePath, err)
						}
						log.Infof("Skipping the template version: %s, error: %v", subfilePath, err)
					}
				} else if strings.HasPrefix(subfile.Name(), "catalogIcon") {
					newTemplate.IconLink = newTemplate.Id + "?image"
					PathToImage[newTemplate.Path] = subfile.Name()
				} else if strings.HasPrefix(strings.ToLower(subfile.Name()), "readme") {
					newTemplate.ReadmeLink = newTemplate.Id + "?readme"
					PathToReadme[newTemplate.Path] = subfile.Name()
				}
			}
		}

		cat.metadata[newTemplate.Path] = newTemplate
	}

	return nil
}