consul

README

consul

Package consul implements GoFrame gcfg.Adapter using consul service.

Installation

go get -u github.com/gogf/gf/contrib/config/consul/v2

Usage

Create a custom boot package

If you wish using configuration from consul globally, it is strongly recommended creating a custom boot package in very top import, which sets the Adapter of default configuration instance before any other package boots.

package boot

import (
	consul "github.com/gogf/gf/contrib/config/consul/v2"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gctx"
	"github.com/hashicorp/consul/api"
	"github.com/hashicorp/go-cleanhttp"
)

func init() {
	var (
		ctx          = gctx.GetInitCtx()
		consulConfig = api.Config{
			Address:    "127.0.0.1:8500",
			Scheme:     "http",
			Datacenter: "dc1",
			Transport:  cleanhttp.DefaultPooledTransport(),
			Token:      "3f8aeba2-f1f7-42d0-b912-fcb041d4546d",
		}
		configPath = "server/message"
	)

	adapter, err := consul.New(ctx, consul.Config{
		ConsulConfig: consulConfig,
		Path:   configPath,
		Watch:  true,
	})
	if err != nil {
		g.Log().Fatalf(ctx, `New consul adapter error: %+v`, err)
	}

	g.Cfg().SetAdapter(adapter)
}

Import boot package in top of main

It is strongly recommended import your boot package in top of your main.go.

Note the top import: _ "github.com/gogf/gf/example/config/consul/boot" .

package main

import (
	_ "github.com/gogf/gf/example/config/consul/boot"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gctx"
)

func main() {
	var ctx = gctx.GetInitCtx()

	// Available checks.
	g.Dump(g.Cfg().Available(ctx))

	// All key-value configurations.
	g.Dump(g.Cfg().Data(ctx))

	// Retrieve certain value by key.
	g.Dump(g.Cfg().MustGet(ctx, "redis.addr"))
}

License

GoFrame consul is licensed under the MIT License, 100% free and open-source, forever.

Documentation

Overview

Package consul implements gcfg.Adapter using consul service.

Index

• func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error)
• type Client
  • func (c *Client) Available(ctx context.Context, resource ...string) (ok bool)
  • func (c *Client) Data(ctx context.Context) (data map[string]interface{}, err error)
  • func (c *Client) Get(ctx context.Context, pattern string) (value interface{}, err error)
• type Config

Functions

func New

func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error)

New creates and returns gcfg.Adapter implementing using consul service.

Types

type Client

type Client struct {
	// contains filtered or unexported fields
}

Client implements gcfg.Adapter implementing using consul service.

func (*Client) Available

func (c *Client) Available(ctx context.Context, resource ...string) (ok bool)

Available checks and returns the backend configuration service is available. The optional parameter `resource` specifies certain configuration resource.

Note that this function does not return error as it just does simply check for backend configuration service.

func (*Client) Data

func (c *Client) Data(ctx context.Context) (data map[string]interface{}, err error)

Data retrieves and returns all configuration data in current resource as map. Note that this function may lead lots of memory usage if configuration data is too large, you can implement this function if necessary.

func (*Client) Get

func (c *Client) Get(ctx context.Context, pattern string) (value interface{}, err error)

Get retrieves and returns value by specified `pattern` in current resource. Pattern like: "x.y.z" for map item. "x.0.y" for slice item.

type Config

type Config struct {
	// api.Config in consul package
	ConsulConfig api.Config `v:"required"`
	// As configuration file path key
	Path string `v:"required"`
	// Watch watches remote configuration updates, which updates local configuration in memory immediately when remote configuration changes.
	Watch bool
	// Logging interface, customized by user, default: glog.New()
	Logger glog.ILogger
}

Config is the configuration object for consul client.