func (s *S) TestBool(c *gc.C) {
sch := schema.Bool()
for _, trueValue := range []interface{}{true, "1", "true", "True", "TRUE"} {
out, err := sch.Coerce(trueValue, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, true)
}
for _, falseValue := range []interface{}{false, "0", "false", "False", "FALSE"} {
out, err := sch.Coerce(falseValue, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, false)
}
out, err := sch.Coerce(42, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: expected bool, got int\(42\)`)
out, err = sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected bool, got nothing")
}
"github.com/wallyworld/core/environs/config"
"github.com/wallyworld/core/schema"
)
var configFields = schema.Fields{
"username": schema.String(),
"password": schema.String(),
"tenant-name": schema.String(),
"auth-url": schema.String(),
"auth-mode": schema.String(),
"access-key": schema.String(),
"secret-key": schema.String(),
"region": schema.String(),
"control-bucket": schema.String(),
"use-floating-ip": schema.Bool(),
"use-default-secgroup": schema.Bool(),
"network": schema.String(),
}
var configDefaults = schema.Defaults{
"username": "",
"password": "",
"tenant-name": "",
"auth-url": "",
"auth-mode": string(AuthUserPass),
"access-key": "",
"secret-key": "",
"region": "",
"control-bucket": "",
"use-floating-ip": false,
"use-default-secgroup": false,
"fmt"
"github.com/wallyworld/core/environs/config"
"github.com/wallyworld/core/schema"
)
const defaultStoragePort = 8040
var (
configFields = schema.Fields{
"bootstrap-host": schema.String(),
"bootstrap-user": schema.String(),
"storage-listen-ip": schema.String(),
"storage-port": schema.ForceInt(),
"storage-auth-key": schema.String(),
"use-sshstorage": schema.Bool(),
}
configDefaults = schema.Defaults{
"bootstrap-user": "",
"storage-listen-ip": "",
"storage-port": defaultStoragePort,
"use-sshstorage": true,
}
)
type environConfig struct {
*config.Config
attrs map[string]interface{}
}
func newEnvironConfig(config *config.Config, attrs map[string]interface{}) *environConfig {
// SetStorageDelay causes any storage download operation in any current
// environment to be delayed for the given duration.
func SetStorageDelay(d time.Duration) {
p := &providerInstance
p.mu.Lock()
defer p.mu.Unlock()
for _, st := range p.state {
st.mu.Lock()
st.storageDelay = d
st.mu.Unlock()
}
}
var configFields = schema.Fields{
"state-server": schema.Bool(),
"broken": schema.String(),
"secret": schema.String(),
"state-id": schema.String(),
}
var configDefaults = schema.Defaults{
"broken": "",
"secret": "pork",
"state-id": schema.Omit,
}
type environConfig struct {
*config.Config
attrs map[string]interface{}
}
}
defer option.error(&err, name, value)
if checker := optionTypeCheckers[option.Type]; checker != nil {
if value, err = checker.Coerce(value, nil); err != nil {
return nil, err
}
return value, nil
}
panic(fmt.Errorf("option %q has unknown type %q", name, option.Type))
}
var optionTypeCheckers = map[string]schema.Checker{
"string": schema.String(),
"int": schema.Int(),
"float": schema.Float(),
"boolean": schema.Bool(),
}
// parse returns an appropriately-typed value for the supplied string, or
// returns an error if it cannot be parsed to the correct type.
func (option Option) parse(name, str string) (_ interface{}, err error) {
defer option.error(&err, name, str)
switch option.Type {
case "string":
return str, nil
case "int":
return strconv.ParseInt(str, 10, 64)
case "float":
return strconv.ParseFloat(str, 64)
case "boolean":
return strconv.ParseBool(str)
import (
"fmt"
"io/ioutil"
"github.com/wallyworld/core/environs/config"
"github.com/wallyworld/core/schema"
)
var configFields = schema.Fields{
"location": schema.String(),
"management-subscription-id": schema.String(),
"management-certificate-path": schema.String(),
"management-certificate": schema.String(),
"storage-account-name": schema.String(),
"force-image-name": schema.String(),
"availability-sets-enabled": schema.Bool(),
}
var configDefaults = schema.Defaults{
"location": "",
"management-certificate": "",
"management-certificate-path": "",
"force-image-name": "",
// availability-sets-enabled is set to Omit (equivalent
// to false) for backwards compatibility.
"availability-sets-enabled": schema.Omit,
}
type azureEnvironConfig struct {
*config.Config
attrs map[string]interface{}
}
"github.com/wallyworld/core/schema"
)
var checkIfRoot = func() bool {
return os.Getuid() == 0
}
var (
configFields = schema.Fields{
"root-dir": schema.String(),
"bootstrap-ip": schema.String(),
"network-bridge": schema.String(),
"container": schema.String(),
"storage-port": schema.ForceInt(),
"namespace": schema.String(),
"lxc-clone": schema.Bool(),
"lxc-clone-aufs": schema.Bool(),
}
// The port defaults below are not entirely arbitrary. Local user web
// frameworks often use 8000 or 8080, so I didn't want to use either of
// these, but did want the familiarity of using something in the 8000
// range.
configDefaults = schema.Defaults{
"root-dir": "",
"network-bridge": "lxcbr0",
"container": string(instance.LXC),
"bootstrap-ip": schema.Omit,
"storage-port": 8040,
"namespace": "",
"lxc-clone": schema.Omit,
"lxc-clone-aufs": schema.Omit,
}
return New(NoDefaults, defined)
}
var fields = schema.Fields{
"type": schema.String(),
"name": schema.String(),
"default-series": schema.String(),
"tools-metadata-url": schema.String(),
"image-metadata-url": schema.String(),
"image-stream": schema.String(),
"authorized-keys": schema.String(),
"authorized-keys-path": schema.String(),
"firewall-mode": schema.String(),
"agent-version": schema.String(),
"development": schema.Bool(),
"admin-secret": schema.String(),
"ca-cert": schema.String(),
"ca-cert-path": schema.String(),
"ca-private-key": schema.String(),
"ca-private-key-path": schema.String(),
"ssl-hostname-verification": schema.Bool(),
"state-port": schema.ForceInt(),
"api-port": schema.ForceInt(),
"syslog-port": schema.ForceInt(),
"rsyslog-ca-cert": schema.String(),
"logging-config": schema.String(),
"charm-store-auth": schema.String(),
"provisioner-safe-mode": schema.Bool(),
"http-proxy": schema.String(),
"https-proxy": schema.String(),
if err != nil {
return
}
m := v.(map[string]interface{})
if _, ok := m["limit"]; !ok {
m["limit"] = c.limit
}
return ifaceSchema.Coerce(m, path)
}
var ifaceSchema = schema.FieldMap(
schema.Fields{
"interface": schema.String(),
"limit": schema.OneOf(schema.Const(nil), schema.Int()),
"scope": schema.OneOf(schema.Const(string(ScopeGlobal)), schema.Const(string(ScopeContainer))),
"optional": schema.Bool(),
},
schema.Defaults{
"scope": string(ScopeGlobal),
"optional": false,
},
)
var charmSchema = schema.FieldMap(
schema.Fields{
"name": schema.String(),
"summary": schema.String(),
"description": schema.String(),
"peers": schema.StringMap(ifaceExpander(int64(1))),
"provides": schema.StringMap(ifaceExpander(nil)),
"requires": schema.StringMap(ifaceExpander(int64(1))),
