func (p *environProvider) Open(cfg *config.Config) (environs.Environ, error) {
p.mu.Lock()
defer p.mu.Unlock()
name := cfg.Name()
ecfg, err := p.newConfig(cfg)
if err != nil {
return nil, err
}
state := p.state[name]
if state == nil {
if ecfg.stateServer() && len(p.state) != 0 {
var old string
for oldName := range p.state {
old = oldName
break
}
panic(fmt.Errorf("cannot share a state between two dummy environs; old %q; new %q", old, name))
}
state = newState(name, p.ops, ecfg.FirewallMode())
p.state[name] = state
}
env := &environ{
state: state,
ecfgUnlocked: ecfg,
}
if err := env.checkBroken("Open"); err != nil {
return nil, err
}
return env, nil
}
func (maasEnvironProvider) Open(cfg *config.Config) (environs.Environ, error) {
logger.Debugf("opening environment %q.", cfg.Name())
env, err := NewEnviron(cfg)
if err != nil {
return nil, err
}
return env, nil
}
func (p environProvider) Open(cfg *config.Config) (environs.Environ, error) {
log.Printf("environs/openstack: opening environment %q", cfg.Name())
e := new(environ)
err := e.SetConfig(cfg)
if err != nil {
return nil, err
}
return e, nil
}
func (p environProvider) Open(cfg *config.Config) (environs.Environ, error) {
log.Infof("environs/ec2: opening environment %q", cfg.Name())
e := new(environ)
err := e.SetConfig(cfg)
if err != nil {
return nil, err
}
e.name = cfg.Name()
return e, nil
}
func NewEnviron(cfg *config.Config) (*maasEnviron, error) {
env := new(maasEnviron)
err := env.SetConfig(cfg)
if err != nil {
return nil, err
}
env.name = cfg.Name()
env.storageUnlocked = NewStorage(env)
return env, nil
}
// Open is specified in the EnvironProvider interface.
func (prov azureEnvironProvider) Open(cfg *config.Config) (environs.Environ, error) {
logger.Debugf("opening environment %q.", cfg.Name())
// We can't return NewEnviron(cfg) directly here because otherwise,
// when err is not nil, we end up with a non-nil returned environ and
// this breaks the loop in cmd/jujud/upgrade.go:run() (see
// http://golang.org/doc/faq#nil_error for the gory details).
environ, err := NewEnviron(cfg)
if err != nil {
return nil, err
}
return environ, nil
}
// Open implements environs.EnvironProvider.Open.
func (environProvider) Open(cfg *config.Config) (env environs.Environ, err error) {
logger.Infof("opening environment %q", cfg.Name())
if _, ok := cfg.AgentVersion(); !ok {
cfg, err = cfg.Apply(map[string]interface{}{
"agent-version": version.CurrentNumber().String(),
})
if err != nil {
return nil, err
}
}
environ := &localEnviron{name: cfg.Name()}
err = environ.SetConfig(cfg)
if err != nil {
logger.Errorf("failure setting config: %v", err)
return nil, err
}
return environ, nil
}
// Validate implements environs.EnvironProvider.Validate.
func (provider environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
// Check for valid changes for the base config values.
if err := config.Validate(cfg, old); err != nil {
return nil, err
}
validated, err := cfg.ValidateUnknownAttrs(configFields, configDefaults)
if err != nil {
return nil, err
}
localConfig := newEnvironConfig(cfg, validated)
// Before potentially creating directories, make sure that the
// root directory has not changed.
if old != nil {
oldLocalConfig, err := provider.newConfig(old)
if err != nil {
return nil, fmt.Errorf("old config is not a valid local config: %v", old)
}
if localConfig.rootDir() != oldLocalConfig.rootDir() {
return nil, fmt.Errorf("cannot change root-dir from %q to %q",
oldLocalConfig.rootDir(),
localConfig.rootDir())
}
if localConfig.storagePort() != oldLocalConfig.storagePort() {
return nil, fmt.Errorf("cannot change storage-port from %v to %v",
oldLocalConfig.storagePort(),
localConfig.storagePort())
}
if localConfig.sharedStoragePort() != oldLocalConfig.sharedStoragePort() {
return nil, fmt.Errorf("cannot change shared-storage-port from %v to %v",
oldLocalConfig.sharedStoragePort(),
localConfig.sharedStoragePort())
}
}
dir := utils.NormalizePath(localConfig.rootDir())
if dir == "." {
dir = config.JujuHomePath(cfg.Name())
localConfig.attrs["root-dir"] = dir
}
// Apply the coerced unknown values back into the config.
return cfg.Apply(localConfig.attrs)
}
// Initialize sets up an initial empty state and returns it.
// This needs to be performed only once for a given environment.
// It returns unauthorizedError if access is unauthorized.
func Initialize(info *Info, cfg *config.Config, opts DialOpts) (rst *State, err error) {
st, err := Open(info, opts)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
st.Close()
}
}()
// A valid environment is used as a signal that the
// state has already been initalized. If this is the case
// do nothing.
if _, err := st.Environment(); err == nil {
return st, nil
} else if !errors.IsNotFoundError(err) {
return nil, err
}
log.Infof("state: initializing environment")
if err := checkEnvironConfig(cfg); err != nil {
return nil, err
}
uuid, err := utils.NewUUID()
if err != nil {
return nil, fmt.Errorf("environment UUID cannot be created: %v", err)
}
ops := []txn.Op{
createConstraintsOp(st, environGlobalKey, constraints.Value{}),
createSettingsOp(st, environGlobalKey, cfg.AllAttrs()),
createEnvironmentOp(st, cfg.Name(), uuid.String()),
}
if err := st.runTransaction(ops); err == txn.ErrAborted {
// The config was created in the meantime.
return st, nil
} else if err != nil {
return nil, err
}
return st, nil
}
// NewEnviron creates a new azureEnviron.
func NewEnviron(cfg *config.Config) (*azureEnviron, error) {
env := azureEnviron{name: cfg.Name()}
err := env.SetConfig(cfg)
if err != nil {
return nil, err
}
// Set up storage.
env.storage = &azureStorage{
storageContext: &environStorageContext{environ: &env},
}
// Set up public storage.
publicContext := publicEnvironStorageContext{environ: &env}
if publicContext.getContainer() == "" {
// No public storage configured. Use EmptyStorage.
env.publicStorage = environs.EmptyStorage
} else {
// Set up real public storage.
env.publicStorage = &azureStorage{storageContext: &publicContext}
}
return &env, nil
}