(Go) How to use toml files?

As title, I want to know how to use toml files from golang.

Before that, I show my toml examples. Is it right?

[datatitle]
enable = true
userids = [
    "12345", "67890"
]
    [datatitle.12345]
    prop1 = 30
    prop2 = 10

    [datatitle.67890]
    prop1 = 30
    prop2 = 10

And then, I want to set these data as type of struct.

As a result I want to access child element as below.

datatitle["12345"].prop1
datatitle["67890"].prop2

Thanks in advance!

First get BurntSushi's toml parser:

go get github.com/BurntSushi/toml

BurntSushi parses toml and maps it to structs, which is what you want.

Then execute the following example and learn from it:

package main

import (
	"github.com/BurntSushi/toml"
	"log"
)

var tomlData = `title = "config"
[feature1]
enable = true
userids = [
  "12345", "67890"
]

[feature2]
enable = false`

type feature1 struct {
	Enable  bool
	Userids []string
}

type feature2 struct {
	Enable bool
}

type tomlConfig struct {
	Title string
	F1    feature1 `toml:"feature1"`
	F2    feature2 `toml:"feature2"`
}

func main() {
	var conf tomlConfig
	if _, err := toml.Decode(tomlData, &conf); err != nil {
		log.Fatal(err)
	}
	log.Printf("title: %s", conf.Title)
	log.Printf("Feature 1: %#v", conf.F1)
	log.Printf("Feature 2: %#v", conf.F2)
}

Notice the tomlData and how it maps to the tomlConfig struct.

See more examples at https://github.com/BurntSushi/toml

A small update for the year 2019 - there is now newer alternative to BurntSushi/toml with a bit richer API to work with .toml files:

pelletier/go-toml (and documentation)

For example having config.toml file (or in memory):

[postgres]
user = "pelletier"
password = "mypassword"

apart from regular marshal and unmarshal of the entire thing into predefined structure (which you can see in the accepted answer) with pelletier/go-toml you can also query individual values like this:

config, err := toml.LoadFile("config.toml")

if err != nil {
    fmt.Println("Error ", err.Error())
} else {

    // retrieve data directly

    directUser := config.Get("postgres.user").(string)
    directPassword := config.Get("postgres.password").(string)
    fmt.Println("User is", directUser, " and password is", directPassword)

    // or using an intermediate object

    configTree := config.Get("postgres").(*toml.Tree)
    user := configTree.Get("user").(string)
    password := configTree.Get("password").(string)
    fmt.Println("User is", user, " and password is", password)

    // show where elements are in the file

    fmt.Printf("User position: %v\n", configTree.GetPosition("user"))
    fmt.Printf("Password position: %v\n", configTree.GetPosition("password"))

    // use a query to gather elements without walking the tree

    q, _ := query.Compile("$..[user,password]")
    results := q.Execute(config)
    for ii, item := range results.Values() {
        fmt.Println("Query result %d: %v", ii, item)
    }
}

UPDATE

<s>There is also spf13/viper that works with .toml config files (among other supported formats), but it might be a bit overkill in many cases.</s>

UPDATE 2

Viper is not really an alternative (credits to @GoForth).

This issue was solved using recommended pkg BurntSushi/toml!!
I did as below and it's part of code.

[toml example]

[title]
enable = true
[title.clientinfo.12345]
distance = 30
some_id = 6

[Golang example]

type TitleClientInfo struct {
    Distance int    `toml:"distance"`
    SomeId  int     `toml:"some_id"`
}

type Config struct {
    Enable     bool     `toml:"enable"`
    ClientInfo map[string]TitleClientInfo `toml:"clientinfo"`
}

var config Config
_, err := toml.Decode(string(d), &config)

And then, it can be used as I expected.

config.ClientInfo[12345].Distance

Thanks!

With solution Viper you can use a configuration file in JSON, TOML, YAML, HCL, INI and others properties formats.

Create file:

./config.toml

First import:

import (config "github.com/spf13/viper")

Initialize:

config.SetConfigName("config")
config.AddConfigPath(".")
err := config.ReadInConfig()
if err != nil {             
	log.Println("ERROR", err.Error())
}

And get the value:

config.GetString("datatitle.12345.prop1")
config.Get("datatitle.12345.prop1").(int32)

Doc.: https://github.com/spf13/viper

e.g.: https://repl.it/@DarlanD/Viper-Examples#main.go

I am using spf13/viper

3rd packages

Status	Project	Starts	Forks
Alive	spf13/viper
Alive	BurntSushi/toml

usage of viper

I tried to use a table to put the code and the contents of the configuration file together, but obviously, the editing did not match the final result, so I put the image up in the hope that it would make it easier for you to compare

package main
import (
    "github.com/spf13/viper"
    "log"
    "os"
)
func main() {
    check := func(err error) {
        if err != nil {
            panic(err)
        }
    }
    myConfigPath := "test_config.toml"
    fh, err := os.OpenFile(myConfigPath, os.O_RDWR, 0666)
    check(err)
    viper.SetConfigType("toml") // do not ignore
    err = viper.ReadConfig(fh)
    check(err)

    // Read
    log.Printf("%#v", viper.GetString("title"))                 // "my config"
    log.Printf("%#v", viper.GetString("DataTitle.12345.prop1")) // "30"
    log.Printf("%#v", viper.GetString("dataTitle.12345.prop1")) // "30"  // case-insensitive
    log.Printf("%#v", viper.GetInt("DataTitle.12345.prop1"))    // 30
    log.Printf("%#v", viper.GetIntSlice("feature1.userids"))    // []int{456, 789}

    // Write
    viper.Set("database", "newuser")
    viper.Set("owner.name", "Carson")
    viper.Set("feature1.userids", []int{111, 222}) // overwrite
    err = viper.WriteConfigAs(myConfigPath)
    check(err)
}

<div class="s-table-container">
<table class="s-table">
<thead>
<tr>
<th>(Write Before)<br>test_config.toml</th>
<th>(After)<br>test_config.toml</th>
</tr>
</thead>
<tbody>
<tr>

<td>

title = "my config"

[datatitle]

  [datatitle.12345]
    prop1 = 30

[feature1]
  userids = [456,789]

</td>
<td>

database = "newuser"  # New
title = "my config"

[datatitle]

  [datatitle.12345]
    prop1 = 30

[feature1]
  userids = [111,222]  # Update

[owner]  # New
  name = "Carson"

</td>

</tr>
</tbody>
</table>
</div>

I am using this 1 go-toml library.

It works great for my uses. I wrote this 2 go util to deal with containerd config.toml file using go-toml

1https://github.com/pelletier/go-toml

2https://github.com/prakashmirji/toml-configer