func (s *storage) Get(file string) (r io.ReadCloser, err error) {
for a := shortAttempt.Start(); a.Next(); {
r, err = s.swift.GetReader(s.containerName, file)
if errors.IsNotFound(err) {
continue
}
}
err, _ = maybeNotFound(err)
if err != nil {
return nil, err
}
return r, nil
}
func (s *storage) Get(file string) (r io.ReadCloser, err error) {
for a := s.ConsistencyStrategy().Start(); a.Next(); {
r, err = s.swift.GetReader(s.containerName, file)
if !gooseerrors.IsNotFound(err) {
break
}
}
err, _ = maybeNotFound(err)
if err != nil {
return nil, err
}
return r, nil
}
// startInstance is the internal version of StartInstance, used by Bootstrap
// as well as via StartInstance itself.
func (e *environ) startInstance(scfg *startInstanceParams) (environs.Instance, error) {
if scfg.tools == nil {
var err error
flags := environs.HighestVersion | environs.CompatVersion
scfg.tools, err = environs.FindTools(e, version.Current, flags)
if err != nil {
return nil, err
}
}
log.Printf("environs/openstack: starting machine %s in %q running tools version %q from %q",
scfg.machineId, e.name, scfg.tools.Binary, scfg.tools.URL)
// TODO(wallyworld) - implement spec lookup
if strings.Contains(scfg.tools.Series, "unknown") || strings.Contains(scfg.tools.Series, "unknown") {
return nil, fmt.Errorf("cannot find image for unknown series or architecture")
}
userData, err := e.userData(scfg)
if err != nil {
return nil, fmt.Errorf("cannot make user data: %v", err)
}
log.Debugf("environs/openstack: openstack user data: %q", userData)
groups, err := e.setUpGroups(scfg.machineId)
if err != nil {
return nil, fmt.Errorf("cannot set up groups: %v", err)
}
var groupNames = make([]nova.SecurityGroupName, len(groups))
for i, g := range groups {
groupNames[i] = nova.SecurityGroupName{g.Name}
}
var server *nova.Entity
for a := shortAttempt.Start(); a.Next(); {
server, err = e.nova().RunServer(nova.RunServerOpts{
Name: state.MachineEntityName(scfg.machineId),
// TODO(wallyworld) - do not use hard coded image
FlavorId: defaultFlavorId,
ImageId: defaultImageId,
UserData: userData,
SecurityGroupNames: groupNames,
})
if err == nil || !gooseerrors.IsNotFound(err) {
break
}
}
if err != nil {
return nil, fmt.Errorf("cannot run instance: %v", err)
}
inst := &instance{e, server}
log.Printf("environs/openstack: started instance %q", inst.Id())
return inst, nil
}
// DiscardSecurityGroup cleans up a security group, it is not an error to
// delete something that doesn't exist.
func DiscardSecurityGroup(e environs.Environ, name string) error {
env := e.(*environ)
novaClient := env.nova()
group, err := novaClient.SecurityGroupByName(name)
if err != nil {
if errors.IsNotFound(err) {
// Group already deleted, done
return nil
}
}
err = novaClient.DeleteSecurityGroup(group.Id)
if err != nil {
return err
}
return nil
}
func (e *environ) terminateInstances(ids []state.InstanceId) error {
if len(ids) == 0 {
return nil
}
var firstErr error
nova := e.nova()
for _, id := range ids {
err := nova.DeleteServer(string(id))
if gooseerrors.IsNotFound(err) {
err = nil
}
if err != nil && firstErr == nil {
firstErr = err
}
}
return firstErr
}
func (e *environ) terminateInstances(ids []instance.Id) error {
if len(ids) == 0 {
return nil
}
var firstErr error
novaClient := e.nova()
for _, id := range ids {
err := novaClient.DeleteServer(string(id))
if gooseerrors.IsNotFound(err) {
err = nil
}
if err != nil && firstErr == nil {
log.Debugf("environs/openstack: error terminating instance %q: %v", id, err)
firstErr = err
}
}
return firstErr
}
// internalStartInstance is the internal version of StartInstance, used by
// Bootstrap as well as via StartInstance itself.
// machineConfig will be filled out with further details, but should contain
// MachineID, MachineNonce, StateInfo, and APIInfo.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (e *environ) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (instance.Instance, *instance.HardwareCharacteristics, error) {
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
arches := possibleTools.Arches()
spec, err := findInstanceSpec(e, &instances.InstanceConstraint{
Region: e.ecfg().region(),
Series: series[0],
Arches: arches,
Constraints: cons,
})
if err != nil {
return nil, nil, err
}
tools, err := possibleTools.Match(tools.Filter{Arch: spec.Image.Arch})
if err != nil {
return nil, nil, fmt.Errorf("chosen architecture %v not present in %v", spec.Image.Arch, arches)
}
machineConfig.Tools = tools[0]
if err := environs.FinishMachineConfig(machineConfig, e.Config(), cons); err != nil {
return nil, nil, err
}
userData, err := environs.ComposeUserData(machineConfig)
if err != nil {
return nil, nil, fmt.Errorf("cannot make user data: %v", err)
}
log.Debugf("environs/openstack: openstack user data; %d bytes", len(userData))
withPublicIP := e.ecfg().useFloatingIP()
var publicIP *nova.FloatingIP
if withPublicIP {
if fip, err := e.allocatePublicIP(); err != nil {
return nil, nil, fmt.Errorf("cannot allocate a public IP as needed: %v", err)
} else {
publicIP = fip
log.Infof("environs/openstack: allocated public IP %s", publicIP.IP)
}
}
config := e.Config()
groups, err := e.setUpGroups(machineConfig.MachineId, config.StatePort(), config.APIPort())
if err != nil {
return nil, nil, fmt.Errorf("cannot set up groups: %v", err)
}
var groupNames = make([]nova.SecurityGroupName, len(groups))
for i, g := range groups {
groupNames[i] = nova.SecurityGroupName{g.Name}
}
var server *nova.Entity
for a := shortAttempt.Start(); a.Next(); {
server, err = e.nova().RunServer(nova.RunServerOpts{
Name: e.machineFullName(machineConfig.MachineId),
FlavorId: spec.InstanceType.Id,
ImageId: spec.Image.Id,
UserData: userData,
SecurityGroupNames: groupNames,
})
if err == nil || !gooseerrors.IsNotFound(err) {
break
}
}
if err != nil {
return nil, nil, fmt.Errorf("cannot run instance: %v", err)
}
detail, err := e.nova().GetServer(server.Id)
if err != nil {
return nil, nil, fmt.Errorf("cannot get started instance: %v", err)
}
inst := &openstackInstance{
e: e,
ServerDetail: detail,
arch: &spec.Image.Arch,
instType: &spec.InstanceType,
}
log.Infof("environs/openstack: started instance %q", inst.Id())
if withPublicIP {
if err := e.assignPublicIP(publicIP, string(inst.Id())); err != nil {
if err := e.terminateInstances([]instance.Id{inst.Id()}); err != nil {
// ignore the failure at this stage, just log it
log.Debugf("environs/openstack: failed to terminate instance %q: %v", inst.Id(), err)
}
return nil, nil, fmt.Errorf("cannot assign public address %s to instance %q: %v", publicIP.IP, inst.Id(), err)
}
log.Infof("environs/openstack: assigned public IP %s to %q", publicIP.IP, inst.Id())
}
return inst, inst.hardwareCharacteristics(), nil
}
// maybeNotFound returns a errors.NotFoundError if the root cause of the specified error is due to a file or
// container not being found.
func maybeNotFound(err error) (error, bool) {
if err != nil && gooseerrors.IsNotFound(err) {
return &coreerrors.NotFoundError{err, ""}, true
}
return err, false
}
// maybeNotFound returns a errors.NotFoundError if the root cause of the specified error is due to a file or
// container not being found.
func maybeNotFound(err error) (error, bool) {
if err != nil && gooseerrors.IsNotFound(err) {
return jujuerrors.NewNotFound(err, ""), true
}
return err, false
}
// maybeNotFound returns a environs.NotFoundError if the root cause of the specified error is due to a file or
// container not being found.
func maybeNotFound(err error) (error, bool) {
if err != nil && errors.IsNotFound(err) {
return &environs.NotFoundError{err}, true
}
return err, false
}