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 }