func importLinkLayerDeviceV1(source map[string]interface{}) (*linklayerdevice, error) {
fields := schema.Fields{
"provider-id": schema.String(),
"machine-id": schema.String(),
"name": schema.String(),
"mtu": schema.Int(),
"type": schema.String(),
"mac-address": schema.String(),
"is-autostart": schema.Bool(),
"is-up": schema.Bool(),
"parent-name": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"provider-id": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "linklayerdevice v1 schema check failed")
}
valid := coerced.(map[string]interface{})
return &linklayerdevice{
ProviderID_: valid["provider-id"].(string),
MachineID_: valid["machine-id"].(string),
Name_: valid["name"].(string),
MTU_: uint(valid["mtu"].(int64)),
Type_: valid["type"].(string),
MACAddress_: valid["mac-address"].(string),
IsAutoStart_: valid["is-autostart"].(bool),
IsUp_: valid["is-up"].(bool),
ParentName_: valid["parent-name"].(string),
}, nil
}
func importFilesystemAttachmentV1(source map[string]interface{}) (*filesystemAttachment, error) {
fields := schema.Fields{
"machine-id": schema.String(),
"provisioned": schema.Bool(),
"read-only": schema.Bool(),
"mount-point": schema.String(),
}
defaults := schema.Defaults{
"mount-point": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "filesystemAttachment v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &filesystemAttachment{
MachineID_: valid["machine-id"].(string),
Provisioned_: valid["provisioned"].(bool),
ReadOnly_: valid["read-only"].(bool),
MountPoint_: valid["mount-point"].(string),
}
return result, nil
}
func importVolumeAttachmentV1(source map[string]interface{}) (*volumeAttachment, error) {
fields := schema.Fields{
"machine-id": schema.String(),
"provisioned": schema.Bool(),
"read-only": schema.Bool(),
"device-name": schema.String(),
"device-link": schema.String(),
"bus-address": schema.String(),
}
checker := schema.FieldMap(fields, nil) // no defaults
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "volumeAttachment v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &volumeAttachment{
MachineID_: valid["machine-id"].(string),
Provisioned_: valid["provisioned"].(bool),
ReadOnly_: valid["read-only"].(bool),
DeviceName_: valid["device-name"].(string),
DeviceLink_: valid["device-link"].(string),
BusAddress_: valid["bus-address"].(string),
}
return result, nil
}
func importSpaceV1(source map[string]interface{}) (*space, error) {
fields := schema.Fields{
"name": schema.String(),
"public": schema.Bool(),
"provider-id": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"provider-id": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "space v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
return &space{
Name_: valid["name"].(string),
Public_: valid["public"].(bool),
ProviderID_: valid["provider-id"].(string),
}, nil
}
func importBlockDeviceV1(source map[string]interface{}) (*blockdevice, error) {
fields := schema.Fields{
"name": schema.String(),
"links": schema.List(schema.String()),
"label": schema.String(),
"uuid": schema.String(),
"hardware-id": schema.String(),
"bus-address": schema.String(),
"size": schema.ForceUint(),
"fs-type": schema.String(),
"in-use": schema.Bool(),
"mount-point": schema.String(),
}
defaults := schema.Defaults{
"links": schema.Omit,
"label": "",
"uuid": "",
"hardware-id": "",
"bus-address": "",
"fs-type": "",
"mount-point": "",
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "block device v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &blockdevice{
Name_: valid["name"].(string),
Links_: convertToStringSlice(valid["links"]),
Label_: valid["label"].(string),
UUID_: valid["uuid"].(string),
HardwareID_: valid["hardware-id"].(string),
BusAddress_: valid["bus-address"].(string),
Size_: valid["size"].(uint64),
FilesystemType_: valid["fs-type"].(string),
InUse_: valid["in-use"].(bool),
MountPoint_: valid["mount-point"].(string),
}
return result, nil
}
func importUserV1(source map[string]interface{}) (*user, error) {
fields := schema.Fields{
"name": schema.String(),
"display-name": schema.String(),
"created-by": schema.String(),
"read-only": schema.Bool(),
"date-created": schema.Time(),
"last-connection": schema.Time(),
"access": schema.String(),
}
// Some values don't have to be there.
defaults := schema.Defaults{
"display-name": "",
"last-connection": time.Time{},
"read-only": false,
}
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "user v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &user{
Name_: valid["name"].(string),
DisplayName_: valid["display-name"].(string),
CreatedBy_: valid["created-by"].(string),
DateCreated_: valid["date-created"].(time.Time),
Access_: valid["access"].(string),
}
lastConn := valid["last-connection"].(time.Time)
if !lastConn.IsZero() {
result.LastConnection_ = &lastConn
}
return result, nil
}
func vlan_2_0(source map[string]interface{}) (*vlan, error) {
fields := schema.Fields{
"id": schema.ForceInt(),
"resource_uri": schema.String(),
"name": schema.OneOf(schema.Nil(""), schema.String()),
"fabric": schema.String(),
"vid": schema.ForceInt(),
"mtu": schema.ForceInt(),
"dhcp_on": schema.Bool(),
// racks are not always set.
"primary_rack": schema.OneOf(schema.Nil(""), schema.String()),
"secondary_rack": schema.OneOf(schema.Nil(""), schema.String()),
}
checker := schema.FieldMap(fields, nil)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "vlan 2.0 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
// Since the primary and secondary racks are optional, we use the two
// part cast assignment. If the case fails, then we get the default value
// we care about, which is the empty string.
primary_rack, _ := valid["primary_rack"].(string)
secondary_rack, _ := valid["secondary_rack"].(string)
name, _ := valid["name"].(string)
result := &vlan{
resourceURI: valid["resource_uri"].(string),
id: valid["id"].(int),
name: name,
fabric: valid["fabric"].(string),
vid: valid["vid"].(int),
mtu: valid["mtu"].(int),
dhcp: valid["dhcp_on"].(bool),
primaryRack: primary_rack,
secondaryRack: secondary_rack,
}
return result, nil
}
func importEndpointV1(source map[string]interface{}) (*endpoint, error) {
fields := schema.Fields{
"service-name": schema.String(),
"name": schema.String(),
"role": schema.String(),
"interface": schema.String(),
"optional": schema.Bool(),
"limit": schema.Int(),
"scope": schema.String(),
"unit-settings": schema.StringMap(schema.StringMap(schema.Any())),
}
checker := schema.FieldMap(fields, nil) // No defaults.
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "endpoint v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &endpoint{
ServiceName_: valid["service-name"].(string),
Name_: valid["name"].(string),
Role_: valid["role"].(string),
Interface_: valid["interface"].(string),
Optional_: valid["optional"].(bool),
Limit_: int(valid["limit"].(int64)),
Scope_: valid["scope"].(string),
UnitSettings_: make(map[string]map[string]interface{}),
}
for unitname, settings := range valid["unit-settings"].(map[string]interface{}) {
result.UnitSettings_[unitname] = settings.(map[string]interface{})
}
return result, nil
}
func (s *S) TestBool(c *gc.C) {
s.sch = schema.Bool()
for _, trueValue := range []interface{}{true, "1", "true", "True", "TRUE"} {
out, err := s.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 := s.sch.Coerce(falseValue, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, false)
}
out, err := s.sch.Coerce(42, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: expected bool, got int\(42\)`)
out, err = s.sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected bool, got nothing")
}
func (f *PromptingFiller) prompt(name string, attr environschema.Attr) (interface{}, error) {
prompter := f.Prompter
if prompter == nil {
prompter = DefaultPrompter
}
tries := f.MaxTries
if tries == 0 {
tries = 3
}
for i := 0; i < tries; i++ {
val, err := prompter.Prompt(name, attr)
if err != nil {
return nil, errgo.Notef(err, "cannot get input")
}
switch attr.Type {
case environschema.Tbool:
b, err := schema.Bool().Coerce(val, nil)
if err == nil {
return b, nil
}
case environschema.Tint:
i, err := schema.Int().Coerce(val, nil)
if err == nil {
return i, nil
}
case environschema.Tstring:
i, err := schema.String().Coerce(val, nil)
if err == nil {
return i, nil
}
default:
return nil, errgo.Newf("unsupported attribute type %q", attr.Type)
}
}
return nil, errgo.New("too many invalid inputs")
}
"github.com/juju/schema"
"github.com/juju/juju/environs/config"
)
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 {
"io/ioutil"
"os"
"github.com/juju/schema"
"github.com/juju/juju/environs/config"
)
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{}
}
}
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(),
func importServiceV1(source map[string]interface{}) (*service, error) {
fields := schema.Fields{
"name": schema.String(),
"series": schema.String(),
"subordinate": schema.Bool(),
"charm-url": schema.String(),
"cs-channel": schema.String(),
"charm-mod-version": schema.Int(),
"force-charm": schema.Bool(),
"exposed": schema.Bool(),
"min-units": schema.Int(),
"status": schema.StringMap(schema.Any()),
"settings": schema.StringMap(schema.Any()),
"settings-refcount": schema.Int(),
"leader": schema.String(),
"leadership-settings": schema.StringMap(schema.Any()),
"metrics-creds": schema.String(),
"units": schema.StringMap(schema.Any()),
}
defaults := schema.Defaults{
"subordinate": false,
"force-charm": false,
"exposed": false,
"min-units": int64(0),
"leader": "",
"metrics-creds": "",
}
addAnnotationSchema(fields, defaults)
addConstraintsSchema(fields, defaults)
addStatusHistorySchema(fields)
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "service v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &service{
Name_: valid["name"].(string),
Series_: valid["series"].(string),
Subordinate_: valid["subordinate"].(bool),
CharmURL_: valid["charm-url"].(string),
Channel_: valid["cs-channel"].(string),
CharmModifiedVersion_: int(valid["charm-mod-version"].(int64)),
ForceCharm_: valid["force-charm"].(bool),
Exposed_: valid["exposed"].(bool),
MinUnits_: int(valid["min-units"].(int64)),
Settings_: valid["settings"].(map[string]interface{}),
SettingsRefCount_: int(valid["settings-refcount"].(int64)),
Leader_: valid["leader"].(string),
LeadershipSettings_: valid["leadership-settings"].(map[string]interface{}),
StatusHistory_: newStatusHistory(),
}
result.importAnnotations(valid)
if err := result.importStatusHistory(valid); err != nil {
return nil, errors.Trace(err)
}
if constraintsMap, ok := valid["constraints"]; ok {
constraints, err := importConstraints(constraintsMap.(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.Constraints_ = constraints
}
encodedCreds := valid["metrics-creds"].(string)
// The model stores the creds encoded, but we want to make sure that
// we are storing something that can be decoded.
if _, err := base64.StdEncoding.DecodeString(encodedCreds); err != nil {
return nil, errors.Annotate(err, "metrics credentials not valid")
}
result.MetricsCredentials_ = encodedCreds
status, err := importStatus(valid["status"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.Status_ = status
units, err := importUnits(valid["units"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.setUnits(units)
return result, nil
}
return New(NoDefaults, defined)
}
var fields = schema.Fields{
"type": schema.String(),
"name": schema.String(),
"uuid": schema.UUID(),
"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(),
"launchpad.net/goose/identity"
"github.com/juju/juju/environs/config"
)
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,
func importVolumeV1(source map[string]interface{}) (*volume, error) {
fields := schema.Fields{
"id": schema.String(),
"storage-id": schema.String(),
"binding": schema.String(),
"provisioned": schema.Bool(),
"size": schema.ForceUint(),
"pool": schema.String(),
"hardware-id": schema.String(),
"volume-id": schema.String(),
"persistent": schema.Bool(),
"status": schema.StringMap(schema.Any()),
"attachments": schema.StringMap(schema.Any()),
}
defaults := schema.Defaults{
"storage-id": "",
"binding": "",
"pool": "",
"hardware-id": "",
"volume-id": "",
"attachments": schema.Omit,
}
addStatusHistorySchema(fields)
checker := schema.FieldMap(fields, defaults)
coerced, err := checker.Coerce(source, nil)
if err != nil {
return nil, errors.Annotatef(err, "volume v1 schema check failed")
}
valid := coerced.(map[string]interface{})
// From here we know that the map returned from the schema coercion
// contains fields of the right type.
result := &volume{
ID_: valid["id"].(string),
StorageID_: valid["storage-id"].(string),
Binding_: valid["binding"].(string),
Provisioned_: valid["provisioned"].(bool),
Size_: valid["size"].(uint64),
Pool_: valid["pool"].(string),
HardwareID_: valid["hardware-id"].(string),
VolumeID_: valid["volume-id"].(string),
Persistent_: valid["persistent"].(bool),
StatusHistory_: newStatusHistory(),
}
if err := result.importStatusHistory(valid); err != nil {
return nil, errors.Trace(err)
}
status, err := importStatus(valid["status"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.Status_ = status
attachments, err := importVolumeAttachments(valid["attachments"].(map[string]interface{}))
if err != nil {
return nil, errors.Trace(err)
}
result.setAttachments(attachments)
return result, nil
}
)
// FieldType describes the type of an attribute value.
type FieldType string
// The following constants are the possible type values.
const (
Tstring FieldType = "string"
Tbool FieldType = "bool"
Tint FieldType = "int"
Tattrs FieldType = "attrs"
)
var checkers = map[FieldType]schema.Checker{
Tstring: schema.String(),
Tbool: schema.Bool(),
Tint: schema.ForceInt(),
Tattrs: attrsC{},
}
// Alternative possibilities to ValidationSchema to bear in mind for
// the future:
// func (s Fields) Checker() schema.Checker
// func (s Fields) Validate(value map[string]interface{}) (v map[string] interface{}, extra []string, err error)
// ValidationSchema returns values suitable for passing to
// schema.FieldMap to create a schema.Checker that will validate the given fields.
// It will return an error if the fields are invalid.
//
// The Defaults return value will contain entries for all non-mandatory
// attributes set to schema.Omit. It is the responsibility of the
// ebsProvider creates volume sources which use AWS EBS volumes.
type ebsProvider struct{}
var _ storage.Provider = (*ebsProvider)(nil)
var ebsConfigFields = schema.Fields{
EBS_VolumeType: schema.OneOf(
schema.Const(volumeTypeMagnetic),
schema.Const(volumeTypeSsd),
schema.Const(volumeTypeProvisionedIops),
schema.Const(volumeTypeStandard),
schema.Const(volumeTypeGp2),
schema.Const(volumeTypeIo1),
),
EBS_IOPS: schema.ForceInt(),
EBS_Encrypted: schema.Bool(),
}
var ebsConfigChecker = schema.FieldMap(
ebsConfigFields,
schema.Defaults{
EBS_VolumeType: volumeTypeMagnetic,
EBS_IOPS: schema.Omit,
EBS_Encrypted: false,
},
)
type ebsConfig struct {
volumeType string
iops int
encrypted bool
if uuid, ok := c[ControllerUUIDKey].(string); ok && !utils.IsValidUUIDString(uuid) {
return errors.Errorf("controller-uuid: expected UUID, got string(%q)", uuid)
}
return nil
}
// GenerateControllerCertAndKey makes sure that the config has a CACert and
// CAPrivateKey, generates and returns new certificate and key.
func GenerateControllerCertAndKey(caCert, caKey string, hostAddresses []string) (string, string, error) {
return cert.NewDefaultServer(caCert, caKey, hostAddresses)
}
var configChecker = schema.FieldMap(schema.Fields{
AuditingEnabled: schema.Bool(),
APIPort: schema.ForceInt(),
StatePort: schema.ForceInt(),
IdentityURL: schema.String(),
IdentityPublicKey: schema.String(),
SetNUMAControlPolicyKey: schema.Bool(),
AutocertURLKey: schema.String(),
AutocertDNSNameKey: schema.String(),
AllowModelAccessKey: schema.Bool(),
}, schema.Defaults{
APIPort: DefaultAPIPort,
AuditingEnabled: DefaultAuditingEnabled,
StatePort: DefaultStatePort,
IdentityURL: schema.Omit,
IdentityPublicKey: schema.Omit,
SetNUMAControlPolicyKey: DefaultNUMAControlPolicy,
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))),
ebsssdPool, _ := storage.NewConfig("ebs-ssd", EBS_ProviderType, map[string]interface{}{
EBS_VolumeType: volumeTypeSsd,
})
defaultPools := []*storage.Config{
ebsssdPool,
}
poolmanager.RegisterDefaultStoragePools(defaultPools)
}
// ebsProvider creates volume sources which use AWS EBS volumes.
type ebsProvider struct{}
var _ storage.Provider = (*ebsProvider)(nil)
var ebsConfigFields = schema.Fields{
storage.Persistent: schema.Bool(),
EBS_VolumeType: schema.OneOf(
schema.Const(volumeTypeMagnetic),
schema.Const(volumeTypeSsd),
schema.Const(volumeTypeProvisionedIops),
schema.Const(volumeTypeStandard),
schema.Const(volumeTypeGp2),
schema.Const(volumeTypeIo1),
),
EBS_IOPS: schema.ForceInt(),
EBS_Encrypted: schema.Bool(),
}
var ebsConfigChecker = schema.FieldMap(
ebsConfigFields,
schema.Defaults{
// 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{}
}
// Persistent is true if storage survives the lifecycle of the
// machine to which it is attached.
Persistent = "persistent"
)
// Config defines the configuration for a storage source.
type Config struct {
name string
provider ProviderType
attrs map[string]interface{}
persistent bool
}
var fields = schema.Fields{
Persistent: schema.Bool(),
}
var configChecker = schema.FieldMap(
fields,
schema.Defaults{
Persistent: false,
},
)
// NewConfig creates a new Config for instantiating a storage source.
func NewConfig(name string, provider ProviderType, attrs map[string]interface{}) (*Config, error) {
out, err := configChecker.Coerce(attrs, nil)
if err != nil {
return nil, errors.Annotate(err, "validating common storage config")
}
}
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)
}
if uuid, ok := c[ControllerUUIDKey].(string); ok && !utils.IsValidUUIDString(uuid) {
return errors.Errorf("controller-uuid: expected UUID, got string(%q)", uuid)
}
return nil
}
// GenerateControllerCertAndKey makes sure that the config has a CACert and
// CAPrivateKey, generates and returns new certificate and key.
func GenerateControllerCertAndKey(caCert, caKey string, hostAddresses []string) (string, string, error) {
return cert.NewDefaultServer(caCert, caKey, hostAddresses)
}
var configChecker = schema.FieldMap(schema.Fields{
AuditingEnabled: schema.Bool(),
ApiPort: schema.ForceInt(),
StatePort: schema.ForceInt(),
IdentityURL: schema.String(),
IdentityPublicKey: schema.String(),
SetNumaControlPolicyKey: schema.Bool(),
}, schema.Defaults{
ApiPort: DefaultAPIPort,
AuditingEnabled: DefaultAuditingEnabled,
StatePort: DefaultStatePort,
IdentityURL: schema.Omit,
IdentityPublicKey: schema.Omit,
SetNumaControlPolicyKey: DefaultNumaControlPolicy,
})