Shifna Zarnaz
3 min read

Performing Git Operations and Modifying YAML Files with Go

Introduction:

Git is a powerful version control system widely used in software development to track changes and collaborate on projects.

Code Explanation:

1. Importing Packages:

                    
                      import (
                        "bytes"
                        "fmt"
                        "html/template"
                        "io/ioutil"
                        "log"
                        "os"
                        "path/filepath"
                       
                        "gopkg.in/src-d/go-git.v4"
                        "gopkg.in/src-d/go-git.v4/config"
                        "gopkg.in/src-d/go-git.v4/plumbing/object"
                        "gopkg.in/src-d/go-git.v4/plumbing/transport/http"
                       )

2.Reading the YAML File: The code starts by reading the contents of an ingress.yaml file using the ioutil.ReadFile function. The file contents are stored in the file variable.

            
              func main() {
                // create new Git repository
                path := "/home/xxx/newproj"
                filePath := "/home/xxx/newproj/gitplugin/ingress.yaml"
                
                file, err := ioutil.ReadFile(filePath)
                if err != nil {
                 log.Fatal("File Reading error", err)
                }

3. Template Parsing and Execution: The code then defines a template using the text/template package. The template is parsed using the template.New function and stored in the tmpl variable. It allows us to define placeholders in the YAML file that can be dynamically replaced with values. In this example, we define a placeholder called Host.

    
      // Define the values for the template
      values := map[string]string{
       "Host": "xxx",
      }
     
      // Parse the template file
      tmpl, err := template.New("ingress").Parse(string(file))
      if err != nil {
       log.Fatal("Template Parsing error", err)
      }

4. Writing the Modified File: The template is executed with a set of values, and the output is written to the buf variable using the Execute method. The modified YAML content is then written back to the ingress.yaml file using the ioutil.WriteFile function.

    
      var buf bytes.Buffer

      // Execute the template with the provided values, writing the output to the buffer
      err = tmpl.Execute(&buf, values)
      if err != nil {
       fmt.Println("Error executing template:", err)
       os.Exit(1)
      }
      
      // Write the modified file to the same location
      err = ioutil.WriteFile(filePath, buf.Bytes(), 0644)
      if err != nil {
       log.Fatal("Writing file error", err)
      }
5.Initializing a Git Repository: Next, the code initializes a new Git repository at the specified path using the git.PlainInit function from the go-git package. 
    
      repo, err := git.PlainInit(path, false)
      if err != nil {
       fmt.Printf("Error creating Git repository: %s\n", err)
       os.Exit(1)
      }

6. Adding a Remote Repository: To establish a connection with a remote repository, the code adds a remote repository URL to the Git configuration using the CreateRemote method. In this example, we use an SSH URL to connect to the remote repository.

    
      auth := &http.BasicAuth{
        Username: "xxxx",
        Password: "replace with git token",
       }
       remote, err := repo.CreateRemote(&config.RemoteConfig{
        Name: "origin",
        URLs: []string{"git@github.com:xxx/gitplugin.git"},
      
        //URLs: []string{resp.giturl},
       })
       if err != nil {
        fmt.Printf("Error creating remote: %s\n", err)
        os.Exit(1)
       }

7. Getting YAML Files: The code retrieves a list of YAML files in a specified directory using the filepath.Glob function. This allows for easy management of multiple YAML files within a folder.

    
      new := "/home/xxx/newproj/gitplugin"
      yamls, err := filepath.Glob(filepath.Join(new, "*.yaml"))
     
      if err != nil {
       fmt.Printf("Error getting YAML files: %s\n", err)
       os.Exit(1)
      }
      fmt.Println("Yaml File is", yamls)

8.Adding Files to Git Index: All the YAML files found in the specified directory are added to the Git index using the worktree. Add method. This prepares the files for the next commit.

    
      // add all YAML files to Git index
      worktree, err := repo.Worktree()
      if err != nil {
       fmt.Printf("Error getting worktree: %s\n", err)
       os.Exit(1)
      }
      _, err = worktree.Add(".")
      if err != nil {
       fmt.Printf("Error adding files to index: %s\n", err)
       os.Exit(1)
      }

9. Committing Changes: A new commit is created using the worktree.Commit method, which includes a commit message and author details. 

    
      commit, err := worktree.Commit("Add YAML files", &git.CommitOptions{
        Author: &object.Signature{
         Name:  "xxx",
         Email: "xxx@gmail.com",
        },
       })
       if err != nil {
        fmt.Printf("Error committing changes: %s\n", err)
        os.Exit(1)
       }
       fmt.Println("Commit is", commit)

10.Pushing Changes to Remote Repository: Finally, the code pushes the committed changes to the remote repository using the remote.Push method. The provided authentication credentials ensure secure communication with the remote repository.

    
      err = remote.Push(&git.PushOptions{
        Auth:       auth,
        RemoteName: "origin",
        RefSpecs:   []config.RefSpec{"refs/heads/master:refs/heads/master"},
       })
       if err != nil {
        fmt.Printf("Error while pushing the file: %s\n", err)
        os.Exit(1)
       }

Conclusion:

In this blog post, we have explored a Go code snippet that demonstrates how to perform Git operations and modify YAML files programmatically. We have seen how to read a YAML file, parse and execute a template, write the modified content back to the file, initialize a Git repository, add files to the Git index, commit changes, and push them to a remote repository. This code snippet can be a valuable starting point for automating Git workflows and managing YAML files within your projects. Feel free to experiment and enhance the code based on your specific requirements. Happy coding!