Golang model.Template类代码示例

func readRancherCompose(relativePath string, newTemplate *model.Template) error {

	composeBytes, err := readFile(relativePath, "rancher-compose.yml")
	if err != nil {
		return err
	}

	catalogConfig, err := lookup.ParseCatalogConfig(*composeBytes)
	if err != nil {
		return err
	}

	newTemplate.Questions = catalogConfig.Questions
	newTemplate.Name = catalogConfig.Name
	newTemplate.Description = catalogConfig.Description
	newTemplate.Version = catalogConfig.Version
	newTemplate.MinimumRancherVersion = catalogConfig.MinimumRancherVersion
	newTemplate.Output = catalogConfig.Output
	newTemplate.Labels = catalogConfig.Labels
	binding, err := model.CreateBindings(relativePath)
	if err != nil {
		return err
	}
	newTemplate.Bindings = binding
	newTemplate.MaximumRancherVersion = catalogConfig.MaximumRancherVersion
	newTemplate.UpgradeFrom = catalogConfig.UpgradeFrom
	return nil
}

func readTemplateConfig(relativePath string, template *model.Template) {
	filename, err := filepath.Abs(relativePath + "/config.yml")
	if err != nil {
		log.Errorf("Error forming path to config file at path: %s, error: %v", relativePath, err)
	}

	yamlFile, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Errorf("Error reading config file under template: %s, error: %v", relativePath, err)
	} else {
		config := make(map[string]string)

		//Read the config.yml file
		err = yaml.Unmarshal(yamlFile, &config)
		if err != nil {
			log.Errorf("Error unmarshalling config.yml under template: %s, error: %v", relativePath, err)
		} else {
			template.Name = config["name"]
			template.Category = config["category"]
			template.Description = config["description"]
			template.Version = config["version"]
			if config["uuid"] != "" {
				template.UUID = config["uuid"]
			}
		}
	}
}

func readTemplateConfig(relativePath string, template *model.Template) {
	filename, err := filepath.Abs(relativePath + "/config.yml")
	if err != nil {
		log.Errorf("Error forming path to config file at path: %s, error: %v", relativePath, err)
	}

	yamlFile, err := ioutil.ReadFile(filename)
	if err != nil {
		log.Errorf("Error reading config file under template: %s, error: %v", relativePath, err)
	} else {
		config := make(map[string]interface{})

		//Read the config.yml file
		err = yaml.Unmarshal(yamlFile, &config)
		if err != nil {
			log.Errorf("Error unmarshalling config.yml under template: %s, error: %v", relativePath, err)
		} else {
			template.Name, _ = config["name"].(string)
			template.Category, _ = config["category"].(string)
			template.Description, _ = config["description"].(string)
			template.Version, _ = config["version"].(string)
			template.Maintainer, _ = config["maintainer"].(string)
			template.License, _ = config["license"].(string)
			template.ProjectURL, _ = config["projectURL"].(string)
			template.IsSystem, _ = config["isSystem"].(string)
			template.DefaultVersion, _ = config["version"].(string)
			template.Labels = map[string]string{}

			labels, _ := config["labels"].(map[interface{}]interface{})
			for k, v := range labels {
				template.Labels[fmt.Sprint(k)] = fmt.Sprint(v)
			}
		}
	}
}

func GetNewTemplateVersions(templateUUID string) model.Template {
	templateMetadata := model.Template{}
	path := UUIDToPath[templateUUID]
	if path != "" {
		//refresh the catalog and sync any new changes
		RefreshCatalog()

		//find the base template metadata name
		tokens := strings.Split(path, "/")
		parentPath := tokens[0]
		cVersion := tokens[1]
		currentVersion, err := strconv.Atoi(cVersion)

		if err != nil {
			log.Debugf("Error %v reading Current Version from path: %s for uuid: %s", err, path, templateUUID)
		} else {
			templateMetadata, ok := Catalog[parentPath]
			if ok {
				log.Debugf("Template found by uuid: %s", templateUUID)
				copyOfversionLinks := make(map[string]string)
				for key, value := range templateMetadata.VersionLinks {
					if value != path {
						otherVersionTokens := strings.Split(value, "/")
						oVersion := otherVersionTokens[1]
						otherVersion, err := strconv.Atoi(oVersion)

						if err == nil && otherVersion > currentVersion {
							copyOfversionLinks[key] = value
						}
					} else {
						templateMetadata.Version = key
					}
				}
				templateMetadata.VersionLinks = copyOfversionLinks
				return templateMetadata
			} else {
				log.Debugf("Template metadata not found by uuid: %s", templateUUID)
			}
		}
	} else {
		log.Debugf("Template  path not found by uuid: %s", templateUUID)
	}

	return templateMetadata
}

//ReadTemplateVersion reads the template version details
func ReadTemplateVersion(path string) model.Template {

	dirList, err := ioutil.ReadDir(catalogRoot + path)
	newTemplate := model.Template{}
	newTemplate.Path = path

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

		var foundIcon bool

		for _, subfile := range dirList {
			if strings.HasPrefix(subfile.Name(), "catalogIcon") {

				newTemplate.IconLink = path + "/" + subfile.Name()
				foundIcon = true

			} else if strings.HasPrefix(subfile.Name(), "docker-compose") {

				newTemplate.DockerCompose = string(*(readFile(catalogRoot+path, subfile.Name())))

			} else if strings.HasPrefix(subfile.Name(), "rancher-compose") {

				readRancherCompose(path, &newTemplate)
			}
		}
		if !foundIcon {
			//use the parent icon
			tokens := strings.Split(path, "/")
			parentPath := tokens[0]
			parentMetadata, ok := Catalog[parentPath]
			if ok {
				newTemplate.IconLink = parentMetadata.IconLink
			} else {
				log.Debugf("Could not find the parent metadata %s", parentPath)
			}
		}
	}

	return newTemplate

}

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
}

func PopulateTemplateLinks(r *http.Request, template *model.Template, resourceType string) map[string]string {

	copyOfversionLinks := make(map[string]string)
	for key, value := range template.VersionLinks {
		copyOfversionLinks[key] = BuildURL(r, resourceType, value)
	}

	template.IconLink = BuildURL(r, "image", template.IconLink)

	return copyOfversionLinks
}

func readRancherCompose(relativePath string, newTemplate *model.Template) {

	composeBytes := readFile(catalogRoot+relativePath, "rancher-compose.yml")
	newTemplate.RancherCompose = string(*composeBytes)

	//read the questions section
	RC := make(map[string]model.RancherCompose)
	err := yaml.Unmarshal(*composeBytes, &RC)
	if err != nil {
		log.Errorf("Error unmarshalling %s under template: %s, error: %v", "rancher-compose.yml", relativePath, err)
	} else {
		newTemplate.Questions = RC[".catalog"].Questions
		newTemplate.Name = RC[".catalog"].Name
		newTemplate.UUID = RC[".catalog"].UUID
		newTemplate.Description = RC[".catalog"].Description
		newTemplate.Version = RC[".catalog"].Version

		if newTemplate.UUID != "" {
			//store uuid -> path map
			UUIDToPath[newTemplate.UUID] = relativePath
			log.Debugf("UUIDToPath map: %v", UUIDToPath)
		}
	}

}

func walkCatalog(path string, f os.FileInfo, err error) error {

	if f.IsDir() && metadataFolder.MatchString(path) {

		log.Debugf("Reading metadata folder for template:%s", f.Name())
		newTemplate := model.Template{}
		newTemplate.Path = f.Name()

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

		//list the folders under the root level
		newTemplate.VersionLinks = make(map[string]string)
		dirList, err := ioutil.ReadDir(path)
		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{}
					readRancherCompose(f.Name()+"/"+subfile.Name(), &subTemplate)
					if subTemplate.UUID != "" {
						UUIDToPath[subTemplate.UUID] = f.Name() + "/" + subfile.Name()
						log.Debugf("UUIDToPath map: %v", UUIDToPath)
					}
					newTemplate.VersionLinks[subTemplate.Version] = f.Name() + "/" + subfile.Name()
				} else if strings.HasPrefix(subfile.Name(), "catalogIcon") {
					newTemplate.IconLink = f.Name() + "/" + subfile.Name()
				}
			}
		}

		Catalog[f.Name()] = newTemplate
	}
	return nil
}

func ReadTemplateVersion(path string) model.Template {

	dirList, err := ioutil.ReadDir(catalogRoot + path)
	newTemplate := model.Template{}
	newTemplate.Path = path

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

		var foundConfig, foundIcon bool

		for _, subfile := range dirList {

			if strings.HasPrefix(subfile.Name(), "config.yml") {

				foundConfig = true
				readTemplateConfig(catalogRoot+path, &newTemplate)
				if newTemplate.UUID != "" {
					//store uuid -> path map
					UUIDToPath[newTemplate.UUID] = path
					log.Debugf("UUIDToPath map: %v", UUIDToPath)
				}
			} else if strings.HasPrefix(subfile.Name(), "catalogIcon") {

				newTemplate.IconLink = path + "/" + subfile.Name()
				foundIcon = true

			} else if strings.HasPrefix(subfile.Name(), "docker-compose") {

				newTemplate.DockerCompose = string(*(readFile(catalogRoot+path, subfile.Name())))

			} else if strings.HasPrefix(subfile.Name(), "rancher-compose") {

				composeBytes := readFile(catalogRoot+path, subfile.Name())
				newTemplate.RancherCompose = string(*composeBytes)

				//read the questions section
				RC := make(map[string]model.RancherCompose)
				err := yaml.Unmarshal(*composeBytes, &RC)
				if err != nil {
					log.Errorf("Error unmarshalling %s under template: %s, error: %v", subfile.Name(), path, err)
				} else {
					newTemplate.Questions = RC[".stack"].Questions
				}
			}
		}

		if !foundConfig {
			//use the parent config
			tokens := strings.Split(path, "/")
			parentPath := tokens[0]
			parentMetadata, ok := Catalog[parentPath]
			if ok {
				newTemplate.Name = parentMetadata.Name
				newTemplate.Category = parentMetadata.Category
				newTemplate.Description = parentMetadata.Description
				newTemplate.Version = parentMetadata.Version
			} else {
				log.Debugf("Could not find the parent metadata %s", parentPath)
			}
		}

		if !foundIcon {
			//use the parent icon
			tokens := strings.Split(path, "/")
			parentPath := tokens[0]
			parentMetadata, ok := Catalog[parentPath]
			if ok {
				newTemplate.IconLink = parentMetadata.IconLink
			} else {
				log.Debugf("Could not find the parent metadata %s", parentPath)
			}
		}
	}

	return newTemplate

}

//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
}