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("Deleting temporary keypair...") 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)) } }
func TestCreateServerWithKeyPair(t *testing.T) { client, err := newClient() th.AssertNoErr(t, err) if testing.Short() { t.Skip("Skipping test that requires server creation in short mode.") } privateKey, err := rsa.GenerateKey(rand.Reader, 2048) publicKey := privateKey.PublicKey pub, err := ssh.NewPublicKey(&publicKey) th.AssertNoErr(t, err) pubBytes := ssh.MarshalAuthorizedKey(pub) pk := string(pubBytes) kp, err := keypairs.Create(client, keypairs.CreateOpts{ Name: keyName, PublicKey: pk, }).Extract() th.AssertNoErr(t, err) t.Logf("Created key pair: %s\n", kp) choices, err := ComputeChoicesFromEnv() th.AssertNoErr(t, err) name := tools.RandomString("Gophercloud-", 8) t.Logf("Creating server [%s] with key pair.", name) serverCreateOpts := servers.CreateOpts{ Name: name, FlavorRef: choices.FlavorID, ImageRef: choices.ImageID, } server, err := servers.Create(client, keypairs.CreateOptsExt{ serverCreateOpts, keyName, }).Extract() th.AssertNoErr(t, err) defer servers.Delete(client, server.ID) if err = waitForStatus(client, server, "ACTIVE"); err != nil { t.Fatalf("Unable to wait for server: %v", err) } server, err = servers.Get(client, server.ID).Extract() t.Logf("Created server: %+v\n", server) th.AssertNoErr(t, err) th.AssertEquals(t, server.KeyName, keyName) t.Logf("Deleting key pair [%s]...", kp.Name) err = keypairs.Delete(client, keyName).ExtractErr() th.AssertNoErr(t, err) t.Logf("Deleting server [%s]...", name) }
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 }
func resourceComputeKeypairDelete(d *schema.ResourceData, meta interface{}) error { computeClient, err := meta.(*Config).computeClient() if err != nil { return fmt.Errorf("Error creating ConoHa compute client: %s", err) } err = keypairs.Delete(computeClient, d.Id()).ExtractErr() if err != nil { return fmt.Errorf("Error deleting ConoHa keypair: %s", err) } d.SetId("") return nil }
func (c *GenericClient) DeleteKeyPair(d *Driver, name string) error { if result := keypairs.Delete(c.Compute, name); result.Err != nil { return result.Err } return nil }
// Delete requests the deletion of a previous stored KeyPair from the server. func Delete(client *gophercloud.ServiceClient, name string) os.DeleteResult { return os.Delete(client, name) }