Cómo manejar la configuración en Go [cerrado]

Otra opción es usar TOML, que es un formato similar a INI creado por Tom Preston-Werner. Yo construí un analizador de Go para él que es ampliamente probado. Puede usarlo como otras opciones propuestas aquí. Por ejemplo, si tiene estos datos TOML en something.toml

Age = 198
Cats = [ "Cauchy", "Plato" ]
Pi = 3.14
Perfection = [ 6, 28, 496, 8128 ]
DOB = 1987-07-05T05:45:00Z

Luego puede cargarlo en su programa Go con algo como

type Config struct {
    Age int
    Cats []string
    Pi float64
    Perfection []int
    DOB time.Time
}

var conf Config
if _, err := toml.DecodeFile("something.toml", &conf); err != nil {
    // handle error
}

Normalmente uso JSON para estructuras de datos más complicadas. La desventaja es que fácilmente terminas con un montón de código para decirle al usuario dónde estaba el error, varios casos extremos y qué no.

Para la configuración base (claves api, números de puerto,...) He tenido muy buena suerte con el paquete gcfg. Se basa en el formato git config.

De la documentación:

Configuración de muestra:

; Comment line
[section]
name = value # Another comment
flag # implicit value for bool is true

Estructura go:

type Config struct {
    Section struct {
            Name string
            Flag bool
    }
}

Y el código necesario para leer it:

var cfg Config
err := gcfg.ReadFileInto(&cfg, "myconfig.gcfg")

También admite valores de corte, por lo que puede permitir especificar una clave varias veces y otras características agradables como esa.

Viper es un sistema de gestión de configuración de golang que funciona con JSON, YAML y TOML. Parece bastante interesante.

Simplemente use banderas estándar gocon iniflags.

Las banderas go estándar tienen los siguientes beneficios:

• Idiomático.
• Fácil de usar. Las banderas se pueden agregar y dispersar fácilmente en paquetes arbitrarios que utiliza su proyecto.
• Las banderas tienen soporte listo para usar para los valores predeterminados y la descripción.
• Los indicadores proporcionan una salida estándar de 'ayuda' con valores y descripción predeterminados.

El único inconveniente que tienen las banderas de go estándar-es problemas de administración cuando el número de indicadores utilizados en la aplicación se vuelve demasiado grande.

Iniflags resuelve elegantemente este problema: simplemente modifique dos líneas en su paquete principal y mágicamente gana soporte para leer los valores de flag del archivo ini. Las banderas de los archivos ini se pueden anular pasando nuevos valores en la línea de comandos.

Véase también https://groups.google.com/forum/#! topic / golang-nuts / TByzyPgoAQE para más detalles.

He comenzado a usar Gcfg que usa archivos similares a Ini. Es simple, si quieres algo simple, esta es una buena opción.

Aquí está el código de carga que estoy usando actualmente, que tiene configuraciones predeterminadas y permite banderas de línea de comandos (no mostradas) que anulan algunas de mis configuraciones:

package util

import (
    "code.google.com/p/gcfg"
)

type Config struct {
    Port int
    Verbose bool
    AccessLog string
    ErrorLog string
    DbDriver string
    DbConnection string
    DbTblPrefix string
}

type configFile struct {
    Server Config
}

const defaultConfig = `
    [server]
    port = 8000
    verbose = false
    accessLog = -
    errorLog  = -
    dbDriver     = mysql
    dbConnection = testuser:TestPasswd9@/test
    dbTblPrefix  =
`

func LoadConfiguration(cfgFile string, port int, verbose bool) Config {
    var err error
    var cfg configFile

    if cfgFile != "" {
        err = gcfg.ReadFileInto(&cfg, cfgFile)
    } else {
        err = gcfg.ReadStringInto(&cfg, defaultConfig)
    }

    PanicOnError(err)

    if port != 0 {
        cfg.Server.Port = port
    }
    if verbose {
        cfg.Server.Verbose = true
    }

    return cfg.Server
}

Echa un vistazo a gonfig

// load
config, _ := gonfig.FromJson(myJsonFile)
// read with defaults
host, _ := config.GetString("service/host", "localhost")
port, _ := config.GetInt("service/port", 80)
test, _ := config.GetBool("service/testing", false)
rate, _ := config.GetFloat("service/rate", 0.0)
// parse section into target structure
config.GetAs("service/template", &template)

Https://github.com/spf13/viper y https://github.com/zpatrick/go-config son unas bibliotecas bastante buenas para los archivos de configuración.

Escribí una sencilla biblioteca de configuración ini en golang.

Https://github.com/c4pt0r/cfg

Goroutine-seguro, fácil de usar

package cfg
import (
    "testing"
)

func TestCfg(t *testing.T) {
    c := NewCfg("test.ini")
    if err := c.Load() ; err != nil {
        t.Error(err)
    }
    c.WriteInt("hello", 42)
    c.WriteString("hello1", "World")

    v, err := c.ReadInt("hello", 0)
    if err != nil || v != 42 {
        t.Error(err)
    }

    v1, err := c.ReadString("hello1", "")
    if err != nil || v1 != "World" {
        t.Error(err)
    }

    if err := c.Save(); err != nil {
        t.Error(err)
    }
}

===================Actualización=======================

Recientemente necesito un analizador INI con soporte de sección, y escribo un paquete simple:

github.com/c4pt0r/cfg

U puede analizar INI como usando el paquete "flag":

package main

import (
    "log"
    "github.com/c4pt0r/ini"
)

var conf = ini.NewConf("test.ini")

var (
    v1 = conf.String("section1", "field1", "v1")
    v2 = conf.Int("section1", "field2", 0)
)

func main() {
    conf.Parse()

    log.Println(*v1, *v2)
}

Use toml como este artículo Leyendo los archivos de configuración de la manera correcta

También te puede interesar go-libucl, un conjunto de enlaces Go para UCL, el Lenguaje de Configuración Universal. UCL es un poco como JSON, pero con mejor soporte para humanos: soporta comentarios y construcciones legibles como multiplicadores SI (10k, 40M, etc.).) y tiene un poco menos repetitivo (por ejemplo, comillas alrededor de las teclas). En realidad, está bastante cerca del formato de archivo de configuración nginx, si ya está familiarizado con eso.

Estoy de acuerdo con nemo y escribí una pequeña herramienta para que todo sea realmente fácil.

Bitbucket.org/gotamer/cfg es un paquete de configuración json

• Usted define sus elementos de configuración en su aplicación como una estructura.
• Una plantilla de archivo de configuración json de su estructura se guarda en la primera ejecución
• Puede guardar modificaciones de tiempo de ejecución en la configuración

Véase el doc.ir para un ejemplo

Probé JSON. Funcionó. Pero odio tener que crear la estructura de los campos y tipos exactos que podría estar configurando. Para mí eso era un dolor. Me di cuenta de que era el método utilizado por todas las opciones de configuración que pude encontrar. Tal vez mi experiencia en lenguajes dinámicos me hace ciego a los beneficios de tal verbosidad. Hice un nuevo formato de archivo de configuración simple, y una lib más dinámica para leerlo.

Https://github.com/chrisftw/ezconf

Soy bastante nuevo en el mundo Go, así que podría no ser el camino Go. Pero funciona, es bastante rápido y súper fácil de usar.

Pros

• Super simple
• Menos código

Cons

• No hay matrices ni tipos de mapas
• Formato de archivo muy plano
• Archivos conf no estándar
• Tiene una pequeña convención incorporada, que ahora si mal visto en general en la comunidad Go. (Busca el archivo de configuración en el directorio de configuración)