func (s *StepKeyPair) Cleanup(state multistep.StateBag) {
// If we used an SSH private key file, do not go about deleting
// keypairs
if s.PrivateKeyFile != "" {
return
}
// If no key name is set, then we never created it, so just return
if s.keyName == "" {
return
}
config := state.Get("config").(Config)
ui := state.Get("ui").(packer.Ui)
// We need the v2 compute client
computeClient, err := config.computeV2Client()
if err != nil {
ui.Error(fmt.Sprintf(
"Error cleaning up keypair. Please delete the key manually: %s", s.keyName))
return
}
ui.Say(fmt.Sprintf("Deleting temporary keypair: %s ...", s.keyName))
err = keypairs.Delete(computeClient, s.keyName).ExtractErr()
if err != nil {
ui.Error(fmt.Sprintf(
"Error cleaning up keypair. Please delete the key manually: %s", s.keyName))
}
}
// DeleteKeyPair will delete a specified keypair. A fatal error will occur if
// the keypair failed to be deleted. This works best when used as a deferred
// function.
func DeleteKeyPair(t *testing.T, client *gophercloud.ServiceClient, keyPair *keypairs.KeyPair) {
err := keypairs.Delete(client, keyPair.Name).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete keypair %s: %v", keyPair.Name, err)
}
t.Logf("Deleted keypair: %s", keyPair.Name)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDeleteSuccessfully(t)
err := keypairs.Delete(client.ServiceClient(), "deletedkey").ExtractErr()
th.AssertNoErr(t, err)
}
// tearDown achieves the aims of TearDown()
func (p *openstackp) tearDown(resources *Resources) (err error) {
// throughout we'll ignore errors because we want to try and delete
// as much as possible; we'll end up returning the last error we encountered
// delete servers, except for ourselves
pager := servers.List(p.computeClient, servers.ListOpts{})
err = pager.EachPage(func(page pagination.Page) (bool, error) {
serverList, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
for _, server := range serverList {
if p.ownName != server.Name && strings.HasPrefix(server.Name, resources.ResourceName) {
p.destroyServer(server.ID) // ignore errors, just try to delete others
}
}
return true, nil
})
if p.ownName == "" {
// delete router
if id := resources.Details["router"]; id != "" {
if subnetid := resources.Details["subnet"]; subnetid != "" {
// remove the interface from our router first
_, err = routers.RemoveInterface(p.networkClient, id, routers.RemoveInterfaceOpts{SubnetID: subnetid}).Extract()
}
err = routers.Delete(p.networkClient, id).ExtractErr()
}
// delete network (and its subnet)
if id := resources.Details["network"]; id != "" {
err = networks.Delete(p.networkClient, id).ExtractErr()
}
// delete secgroup
if id := resources.Details["secgroup"]; id != "" {
err = secgroups.Delete(p.computeClient, id).ExtractErr()
}
}
// delete keypair, unless we're running in OpenStack and securityGroup and
// keypair have the same resourcename, indicating our current server needs
// the same keypair we used to spawn our servers
if id := resources.Details["keypair"]; id != "" {
if p.ownName == "" || (p.securityGroup != "" && p.securityGroup != id) {
err = keypairs.Delete(p.computeClient, id).ExtractErr()
resources.PrivateKey = ""
}
}
return
}
func resourceComputeKeypairV2Delete(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
computeClient, err := config.computeV2Client(d.Get("region").(string))
if err != nil {
return fmt.Errorf("Error creating OpenStack compute client: %s", err)
}
err = keypairs.Delete(computeClient, d.Id()).ExtractErr()
if err != nil {
return fmt.Errorf("Error deleting OpenStack keypair: %s", err)
}
d.SetId("")
return nil
}