func()

in dev/import-beats/packages.go [258:432]

• 138 lines of code
• 35 McCabe index (conditional complexity)

func (r *packageRepository) save(outputDir string) error {
	for packageName, content := range r.packages {
		manifest := content.manifest

		log.Printf("%s/%s write package content\n", packageName, manifest.Version)

		packagePath := filepath.Join(outputDir, packageName)
		err := os.MkdirAll(packagePath, 0755)
		if err != nil {
			return errors.Wrapf(err, "cannot make directory for module: '%s'", packagePath)
		}

		m, err := yaml.Marshal(content.manifest)
		if err != nil {
			return errors.Wrapf(err, "marshaling package manifest failed (packageName: %s)", packageName)
		}

		manifestFilePath := filepath.Join(packagePath, "manifest.yml")
		err = ioutil.WriteFile(manifestFilePath, m, 0644)
		if err != nil {
			return errors.Wrapf(err, "writing manifest file failed (path: %s)", manifestFilePath)
		}

		// dataStream
		for _, dataStream := range content.dataStreams {
			dataStreamPath := filepath.Join(packagePath, "data_stream", dataStream.name)
			err := os.MkdirAll(dataStreamPath, 0755)
			if err != nil {
				return errors.Wrapf(err, "cannot make directory for dataStream: '%s'", dataStreamPath)
			}

			// dataStream/manifest.yml
			m, err := yaml.Marshal(dataStream.manifest)
			if err != nil {
				return errors.Wrapf(err, "marshaling data stream manifest failed (dataStreamName: %s)", dataStream.name)
			}

			manifestFilePath := filepath.Join(dataStreamPath, "manifest.yml")
			err = ioutil.WriteFile(manifestFilePath, m, 0644)
			if err != nil {
				return errors.Wrapf(err, "writing data stream manifest file failed (path: %s)", manifestFilePath)
			}

			// dataStream/fields
			if len(dataStream.fields.files) > 0 {
				dataStreamFieldsPath := filepath.Join(dataStreamPath, "fields")
				err := os.MkdirAll(dataStreamFieldsPath, 0755)
				if err != nil {
					return errors.Wrapf(err, "cannot make directory for data stream fields: '%s'", dataStreamPath)
				}

				for fieldsFileName, definitions := range dataStream.fields.files {
					log.Printf("%s: write '%s' file\n", dataStream.name, fieldsFileName)

					fieldsFilePath := filepath.Join(dataStreamFieldsPath, fieldsFileName)
					var fieldsFile []byte

					stripped := definitions.stripped()
					fieldsFile, err := yaml.Marshal(&stripped)
					if err != nil {
						return errors.Wrapf(err, "marshalling fields file failed (path: %s)", fieldsFilePath)
					}
					err = ioutil.WriteFile(fieldsFilePath, fieldsFile, 0644)
					if err != nil {
						return errors.Wrapf(err, "writing fields file failed (path: %s)", fieldsFilePath)
					}
				}
			}

			// dataStream/elasticsearch
			if len(dataStream.elasticsearch.ingestPipelines) > 0 {
				ingestPipelinesPath := filepath.Join(dataStreamPath, "elasticsearch", packages.DirIngestPipeline)
				err := os.MkdirAll(ingestPipelinesPath, 0755)
				if err != nil {
					return errors.Wrapf(err, "cannot make directory for data stream ingest pipelines: '%s'", ingestPipelinesPath)
				}

				for _, ingestPipeline := range dataStream.elasticsearch.ingestPipelines {
					ingestPipelinePath := filepath.Join(ingestPipelinesPath, ingestPipeline.targetFileName)
					log.Printf("write ingest pipeline file '%s'", ingestPipelinePath)

					err := ioutil.WriteFile(ingestPipelinePath, ingestPipeline.body, 0644)
					if err != nil {
						return errors.Wrapf(err, "writing ingest pipeline failed")
					}
				}
			}

			// dataStream/agent/stream
			if len(dataStream.agent.streams) > 0 {
				agentStreamPath := filepath.Join(dataStreamPath, "agent", "stream")
				err := os.MkdirAll(agentStreamPath, 0755)
				if err != nil {
					return errors.Wrapf(err, "cannot make directory for data stream agent stream: '%s'", agentStreamPath)
				}

				for _, agentStream := range dataStream.agent.streams {
					err := ioutil.WriteFile(path.Join(agentStreamPath, agentStream.targetFileName), agentStream.body, 0644)
					if err != nil {
						return errors.Wrapf(err, "writing agent stream file failed")
					}
				}
			}
		}

		// img
		imgDstDir := path.Join(packagePath, "img")
		for _, image := range content.images {
			log.Printf("copy image file '%s' to '%s'", image.source, imgDstDir)
			err := copyFile(image.source, imgDstDir)
			if err != nil {
				return errors.Wrapf(err, "copying file failed")
			}
		}

		// kibana
		if len(content.kibana.files) > 0 {
			kibanaPath := filepath.Join(packagePath, "kibana")

			for objectType, objects := range content.kibana.files {
				resourcePath := filepath.Join(kibanaPath, objectType)

				err := os.MkdirAll(resourcePath, 0755)
				if err != nil {
					return errors.Wrapf(err, "cannot make directory for dashboard files: '%s'", resourcePath)
				}

				for fileName, body := range objects {
					resourceFilePath := filepath.Join(resourcePath, fileName)

					log.Printf("create resource file: %s", resourceFilePath)
					err = ioutil.WriteFile(resourceFilePath, body, 0644)
					if err != nil {
						return errors.Wrapf(err, "writing resource file failed (path: %s)", resourceFilePath)
					}
				}
			}
		}

		// docs
		if len(content.docs) > 0 {
			docsPath := filepath.Join(packagePath, "docs")
			err := os.MkdirAll(docsPath, 0755)
			if err != nil {
				return errors.Wrapf(err, "cannot make directory for docs: '%s'", docsPath)
			}

			for _, doc := range content.docs {
				err = writeDoc(docsPath, doc, content)
				if err != nil {
					return errors.Wrapf(err, "cannot write docs (docsPath: %s, fileName: %s)", docsPath,
						doc.fileName)
				}
			}
		}

		// changelog
		changelog := newChangelog(manifest.Version)

		c, err := yaml.Marshal(changelog)
		if err != nil {
			return errors.Wrap(err, "marshalling changelog failed")
		}

		header := "# newer versions go on top"
		contents := strings.Replace(string(c), "entries:", header, 1) // HACK: cannot marshal sequence at root level!
		c = []byte(contents)

		changelogPath := filepath.Join(packagePath, "changelog.yml")
		if err := ioutil.WriteFile(changelogPath, c, 0644); err != nil {
			return errors.Wrap(err, "writing changelog file failed")
		}
	}
	return nil
}